Systems and methods of refining a search query based on user-specified search keywords

ABSTRACT

After receiving a search keyword provided by a user, a computer selects an archetype for the search keyword. The computer identifies one or more search results in accordance with the archetype and returns at least one of the search results to the user. After selecting the archetype, the computer identifies at least one query operator for the selected archetype, constructs a search query using the query operator, and executes the search query against one or more data sources. Sometimes, the computer solicits user instructions with respect to the archetype and then generates feedback to the user instructions. This process may repeat multiple loops until the user submits a search query execution request, which suggests that the user is satisfied with the customized search query.

RELATED APPLICATIONS

This application relates to U.S. Patent Application, “Systems andmethods of identifying chunks within multiple documents,” filed on Feb.22, 2008, Ser. No. 12/035,541, which is hereby incorporated by referencein its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of displaying document chunks in response to a search request,”filed on Feb. 22, 2008 Ser. No. 12/035,546, which is hereby incorporatedby reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of searching a document for relevant chunks in response to asearch request,” filed on Feb. 22, 2008 Ser. No. 12/035,557, which ishereby incorporated by reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of displaying and re-using document chunks in a documentdevelopment application,” filed on Feb. 22, 2008 Ser. No. 12/035,566,which is hereby incorporated by reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of performing a text replacement within multiple documents,”filed on Feb. 22, 2008 Ser. No. 12/035,574, which is hereby incorporatedby reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of refining chunks identified within multiple documents,” filedon Feb. 22, 2008 Ser. No. 12/035,587, which is hereby incorporated byreference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of pipelining multiple document node streams through a queryprocessor,” filed on Feb. 22, 2008 Ser. No. 12/035,592, which is herebyincorporated by reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of semantically annotating documents of different structures,”filed on Feb. 22, 2008 Ser. No. 12/035,597, which is hereby incorporatedby reference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of adaptively screening matching chunks within documents,” filedon Feb. 22, 2008 Ser. No. 12/035,600, which is hereby incorporated byreference in its entirety.

This application relates to U.S. Patent Application, “Systems andmethods of identifying chunks within inter-related documents,” filed onFeb. 22, 2008 Ser. No. 12/035,607, which is hereby incorporated byreference in its entirety.

FIELD OF THE INVENTION

The present invention relates generally to the field of informationretrieval in a computer system, in particular to systems and methods oflocating information at different sources.

BACKGROUND OF THE INVENTION

The growth of information technology enables a user of a desktop orlaptop computer to easily access information stored within a largenumber of documents at different locations such as the computer's localhard drive or a remote web server on the Internet. But quickly locatingthe information sought by the user within one or more documents remainsa challenging task with today's information retrieval technologies.

In response to search keywords provided by a user, conventional web anddesktop search engines typically return a list of document names withone or two sentences from each document that match the search keywordsas search results. From the one or two matching sentences, the useroften has trouble understanding the meaning of the search keywords inthe context of the document. To determine whether the document has theuser sought-after information, the user has no choice but to open thedocument using its native application (e.g., the Microsoft Officeapplication if the document is a Word document) and repeat the processif the document does not have the information sought by the user.

There are multiple issues with this approach. First, opening a documentusing its native application is a time-consuming operation. Second, andmore importantly, the native application does not highlight anyparticular portion of the document that may contain the user-providedsearch keywords. To locate any search keywords within the document, theuser has to do a new search of the document using a search tool of thenative application. If the search tool can only look for multiple searchkeywords in exactly the same order (which is often the case), the usermay end up finding nothing interesting in the document even if thedocument has a paragraph that contains the multiple search keywords butin a slightly different order. Alternatively, if the user limits thesearch to a subset of the multiple search keywords, many instances ofthe subset of search keywords may be in the document and the user couldspend a significant effort before finding the document content ofinterest.

SUMMARY

The above deficiencies and other problems associated with conventionalsearch tools are reduced or eliminated by the invention disclosed below.In some embodiments, the invention is implemented in a computer systemthat has a graphical user interface (GUI), one or more processors,memory and one or more modules, programs or sets of instructions storedin the memory for performing multiple functions. Instructions forperforming these functions may be included in a computer program productconfigured for execution by one or more processors.

One aspect of the invention involves a computer-implemented methodperformed by a computer. After receiving a search keyword provided by auser, the computer selects an archetype for the search keyword. Thecomputer identifies one or more search results in accordance with thearchetype and returns at least one of the search results to the user.

Another aspect of the invention involves a computer system. The computersystem includes memory, one or more processors, and one or more programsstored in the memory and configured for execution by the one or moreprocessors. The one or more programs include: instructions for receivinga search keyword provided by a user; instructions for selecting anarchetype for the search keyword; instructions for identifying one ormore search results in accordance with the archetype; and instructionsfor returning at least one of the search results to the user.

Another aspect of the invention involves a computer readable storagemedium having stored therein instructions, which when executed by acomputer system cause the computer system to: receive a search keywordprovided by a user; select an archetype for the search keyword; identifyone or more search results in accordance with the archetype; and returnat least one of the search results to the user.

Some embodiments may be implemented on either the client side or theserver side of a client-server network environment.

BRIEF DESCRIPTION OF THE DRAWINGS

The aforementioned features and advantages of the invention as well asadditional features and advantages thereof will be more clearlyunderstood hereinafter as a result of a detailed description ofpreferred embodiments when taken in conjunction with the drawings.

FIG. 1 is a block diagram of an exemplary computer system that includesa front end, a search server including a query engine, a cache engine,an index database, and a stream engine, and one or more data sources inaccordance with some embodiments.

FIG. 2 is a flowchart illustrative of how the front end processesuser-provided search keywords in accordance with some embodiments.

FIG. 3 is a flowchart illustrative of how the query engine generatessearch criteria for the user-provided search keywords in accordance withsome embodiments.

FIG. 4 is a flowchart illustrative of how the cache engine produces aset of candidate document identifiers for the user-provided searchkeywords in accordance with some embodiments.

FIG. 5 is a flowchart illustrative of how the stream engine processescandidate documents retrieved from different data sources in accordancewith some embodiments.

FIG. 6 is a flowchart illustrative of how the cache engine processes thecandidate documents coming out of the stream engine in accordance withsome embodiments.

FIG. 7 is a flowchart illustrative of how the query engine identifiesrelevant chunks within the candidate documents in accordance with someembodiments.

FIG. 8A is a flowchart illustrative of how the stream engine generatessemantic data models for different types of documents in accordance withsome embodiments.

FIG. 8B is a flowchart illustrating a first embodiment of how the queryengine identifies a relevant chunk within a node stream representing acandidate document.

FIG. 8C is a flowchart illustrating a second embodiment of how the queryengine identifies a relevant chunk within a node stream representing acandidate document.

FIG. 9A is a flowchart illustrative of how the stream engine processesmultiple candidate documents to identify candidate chunks in accordancewith some embodiments.

FIG. 9B is an exemplary HTML document to be processed by the streamengine as shown in FIG. 9A in accordance with some embodiments.

FIG. 10A is a block diagram illustrative of how a query mediatorcoordinates the query engine and the stream engine to identify chunkswithin a node stream representing a candidate document in accordancewith some embodiments.

FIG. 10B is a flowchart illustrative of how the stream engine dividesthe node stream into multiple sub-streams using a filter model inaccordance with some embodiments.

FIG. 11A is an exemplary XML document to be processed by the streamengine and the query engine in accordance with some embodiments.

FIG. 11B is an exemplary XQuery to be applied to the XML document inaccordance with some embodiments.

FIG. 11C is a table of input sequences defined by the query engine inaccordance with some embodiments.

FIG. 11D is a flowchart illustrative of how the query engine processesnode sub-streams at different input sequences in accordance with someembodiments.

FIG. 11E is a block diagram illustrative of how a node streamcorresponding to the XML document is divided into multiple nodesub-streams by a finite state machine in accordance with someembodiments.

FIG. 11F is a block diagram illustrative of the input sequences andtheir associated node sub-streams after the first candidate chunk in theXML document is processed in accordance with some embodiments.

FIG. 11G is the search result of applying the XQuery to the nodesub-streams derived from XML document in accordance with someembodiments.

FIG. 12A is a flowchart illustrative of a first process of identifyingone or more documents, each document having one or more chunks thatsatisfy user-specified search keywords, in accordance with someembodiments.

FIG. 12B is a flowchart illustrative of a second process of identifyingone or more document, each document having one or more chunks thatsatisfy user-specified search keywords, in accordance with someembodiments.

FIGS. 12C through 12J are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 12A and 12B in accordance with some embodiments.

FIG. 13A is a flowchart illustrative of a first process of identifyingwithin a document one or more chunks that satisfy user-specified searchkeywords in accordance with some embodiments.

FIG. 13B is a flowchart illustrative of a second process of identifyingwithin a document one or more chunks that satisfy user-specified searchkeywords in accordance with some embodiments.

FIGS. 13C through 13G are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 13A and 13B in accordance with some embodiments.

FIG. 14 is a flowchart illustrative of a process of modeling a documentand identifying within the document one or more chunks that satisfyuser-specified search keywords in accordance with some embodiments.

FIG. 15 is a flowchart illustrative of a process of customizing a searchquery based on user-specified search keywords in accordance with someembodiments.

FIG. 16A is a flowchart illustrative of a process of displaying andre-using search results based on user instructions in accordance withsome embodiments.

FIGS. 16B through 16J are screenshots of a graphical user interface on acomputer display illustrative of features associated with the process asshown in FIG. 16A in accordance with some embodiments.

FIG. 17A is a flowchart illustrative of a process of finding andreplacing text strings in connection with a set of search results basedon user instructions in accordance with some embodiments.

FIG. 17B is a flowchart illustrative of a process of finding andreplacing text strings within a set of documents based on userinstructions in accordance with some embodiments.

FIGS. 17C through 17E are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 17A and 17B in accordance with some embodiments.

FIG. 18A is a flowchart illustrative of a first process of narrowingsearch results based on user instructions in accordance with someembodiments.

FIG. 18B is a flowchart illustrative of a second process of narrowingsearch results based on user instructions in accordance with someembodiments.

FIGS. 18C through 18D are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 18A and 18B in accordance with some embodiments.

FIG. 19 is a flowchart illustrative of a process of alternativelyprocessing document node streams in accordance with some embodiments.

FIG. 20 is a flowchart illustrative of a process of semantically andcontextually annotating documents of different structures in accordancewith some embodiments.

FIG. 21A is a flowchart illustrative of a first process of screeningmatching chunks within a document based on predefined criteria inaccordance with some embodiments.

FIG. 21B is an exemplary HTML document illustrative of the process asshown in FIG. 21A in accordance with some embodiments.

FIG. 21C is a flowchart illustrative of a second process of screeningmatching chunks within a document based on predefined criteria inaccordance with some embodiments.

FIG. 21D is a screenshot of a graphical user interface on a computerdisplay illustrative of features associated with the processes as shownin FIGS. 21A and 21B in accordance with some embodiments.

FIG. 22A is a flowchart illustrative of a process of identifyingcontents matching a search request within a plurality of inter-relateddocuments in accordance with some embodiments.

FIGS. 22B through 22D are screenshots of a graphical user interface on acomputer display illustrative of features associated with the process asshown in FIG. 22A in accordance with some embodiments.

FIG. 23 is a block diagram of an exemplary document search servercomputer in accordance with some embodiments.

FIG. 24 is a block diagram of an exemplary client computer in accordancewith some embodiments.

Like reference numerals refer to corresponding parts throughout theseveral views of the drawings.

DESCRIPTION OF EMBODIMENTS

Reference will now be made in detail to embodiments, examples of whichare illustrated in the accompanying drawings. In the following detaileddescription, numerous specific details are set forth in order to providea thorough understanding of the subject matter presented herein. But itwill be apparent to one skilled in the art that the subject matter maybe practiced without these specific details. In other instances,well-known methods, procedures, components, and circuits have not beendescribed in detail so as not to unnecessarily obscure aspects of theembodiments.

FIG. 1 is a block diagram of an exemplary computer system 100 thatincludes a front end 15, a search server 20, and one or more datasources 70 in accordance with some embodiments. The front end 15 is asoftware application configured to receive and process input from a user10 such as search keywords and present search results to the user 10.The search server 20 further includes a query engine 30, a cache engine40, an index database 50, and a stream engine 60. The data sources 70include storage devices such as file systems on hard drives accessibleto the computer system 100 and remote web servers on the Internet.

At runtime, the front end 15 forwards the user-provided search keywordsto the search server 20 in the form of a search query. In response,different components within the search server 20 work in concert toidentify a set of candidate documents that matches the search keywordsand retrieve the contents of the candidate documents from theirrespective locations at local and/or remote data sources 70. Thedifferent components within the search server 20 then search within theretrieved document contents for chunks that match the search keywordsand return the identified chunks to the front end 15 in the form ofsearch results.

In this application, a document is generally referred to as a dataentity that has textual content, such as a Microsoft Office document, aplain-text document, a PDF document, an email or text message, a webpage, etc. A “candidate chunk” within a document is a portion of thedocument that is semantically and contextually regarded as a unit oftextual content by one skilled in the relevant art. For example, withina Word document, a sentence, a paragraph, a table, a figure's caption,the document's title, header, and footer are candidate chunks.Similarly, a slide within a PowerPoint document, a bullet point withinthe slide, and a cell or a row within an Excel spreadsheet are alsocandidate chunks. A “chunk” or more specifically a “relevant chunk”served as part of the search results is a candidate chunk that satisfiesthe search keywords in accordance with predefined search criteria, e.g.,if the candidate chunk includes at least one instance of one of thesearch keywords.

FIG. 2 is a flowchart illustrative of how the front end 15 processesuser-provided search keywords in accordance with some embodiments. Afterreceiving the search keywords (201), the front end 15 generates a searchquery using the search keywords (203). Depending on the type of data tobe processed by the search server 20, the search query can be written indifferent query languages such as structured query language (SQL) forrelational databases or XQuery for XML data sources. The front end 15then submits the search query to the query engine 30 within the searchserver 20 (205) for further processing.

FIG. 3 is a flowchart illustrative of how the query engine 30 generatessearch criteria for the user-provided search keywords in accordance withsome embodiments. After receiving the search query (302), the queryengine 30 analyzes the query (304) and generates optimized searchcriteria (306). In some embodiments, the query engine 30 also generatesone or more path filters from the search query (308). The path filtersare derived from the user-provided search keywords and search options.The stream engine 60 employs the path filters to exclude documentcontent that is not part of any candidate chunks. A more detaileddescription is provided below in connection with FIGS. 10 and 11. Thequery engine 30 submits both the search criteria and the path filters tothe cache engine 40 (310).

In some embodiments, the query engine 30 generates an optimizedexecution plan for the query according to the capabilities of othercomponents within the search server 20. For example, if the search querycontains a predicate limiting the search to documents at the local harddrive that have been updated within the last two days, the query engine30 has two options. One option is that the query engine 30 keeps thepredicate to itself and waits to apply the predicate to the candidatechunks. In this case, the search server 20 (especially the stream engine60) may have processed more candidate documents than necessary. Theother option is that the query engine 30 pushes the predicate down tothe file system managing the local hard drive through the index database50. In this case, only candidate documents that have been updated withinthe last two days are processed and the stream engine 60 is relievedfrom additional, unnecessary workload.

FIG. 4 is a flowchart illustrative of how the cache engine 40 produces aset of candidate document identifiers for the user-provided searchkeywords in accordance with some embodiments. After receiving the searchcriteria from the query engine (401), the cache engine 40 submits thesearch criteria to the index databases 50. In some embodiments, theindex databases include both a local index database and a remote indexdatabase. The local index database manages index information ofdocuments at the local hard drive and the remote index database managesindex information of documents at a remote document server. In someembodiments, the remote index database refers to the index database of athird-party search engine.

For given user search criteria, the cache engine 40 may search the localindex database (403) if the user is looking for documents at the localhard drive or the remote index database (405) if the user is submittinga search request to a third-party search engine or both. From theseindex databases 50, the cache engine 40 receives respective searchresults (407), e.g., in the form of a set of document references such asURIs, and identifies a candidate document identifier within each searchresult (409). Note that a candidate document is a document that matchesthe search query at the document level, but may or may not at the chunklevel. For example, a PowerPoint document that has slide A matching onesearch keyword and slide B matching another search keyword is acandidate document, but does not have any chunk matching the searchquery. In some embodiments, a universal resource identifier (URI) isused as a document identifier. Thus, documents at the local hard driveand remote web servers can be referenced in the same manner.

In some embodiments, the search results returned by the index databases50 are ordered by the corresponding candidate documents' relevancy tothe search query. Many well-known algorithms for determining adocument's relevancy to a search query can be found in the classic bookentitled “Automatic Information Organization and Retrieval” by G.Salton, McGraw-Hill, New York, 1968, which is incorporated here byreference in its entirety.

In some embodiments, a candidate document's relevancy is at least inpart ranked by the past user activities on the candidate document. Forexample, a candidate document that has been recently accessed by theuser, such as browsing, copying and updating, is given a higher rankthan another candidate document that has never been accessed by the userbefore. In one embodiment, a candidate document's ranking score isdetermined by combining the following two pieces of information:

-   -   The frequency of a search keyword in the document—For each        keyword, the index database 50 may keep information such as a        total count of occurrences of the keyword in a number of        documents and a per-document count of the occurrences of the        keyword. By combining the frequencies of different search        keywords within the same document, a basic ranking score of the        document is computed using a generic inverse frequency        algorithm.    -   The personalized usage weight of the document—A respective        number of points are assigned to each operation the user applies        to the document. For example, the preview operation of a        particular document is given two points, the re-use of content        from the previewed document is given three points, and the        re-use of a specific chunk within the document is given four        points. The total points assigned to the document, when compared        against the total points allocated for the corresponding        document type, yields a personalized ranking score for the        document, which may be combined with the aforementioned basic        ranking score to generate a customized ranking score for the        document.

In some embodiments, a document's relevancy to a search query is notsolely determined at the document level but is, at least in part,determined at the chunk level. For example, the index database 50 maymaintain information about the locations of candidate chunks within eachdocument as well as the distinct ranking information of differentcandidate chunks within the same document relative to different searchkeywords, thereby making it possible to return the relevant chunkswithin the same document in an order consistent with their respectivechunk-level ranking scores.

The cache engine 40 submits a set of candidate document identifiers andpath filters, if any, generated by the query engine 30 to the streamengine 60 for further processing (411).

For illustration, the aforementioned processes in connection with FIGS.2 through 4 are collectively referred to as the “downstream processes25” as shown in FIG. 1. The input to the downstream processes is asearch request including one or more search keywords and its output is aset of candidate document identifiers that identify candidate documentssatisfying the search keywords. For example, a document is deemed to bea candidate document if it includes at least one instance of each searchkeyword. But the fact that each search keyword has a match in acandidate document does not guarantee that the candidate document has achunk relevant to the search request.

As noted above, identifying a chunk within a document requires semanticinformation about the document. Such information is not available in theindex database 50. To find out whether a candidate document has anyrelevant chunk, the search server 20 needs to retrieve the document andanalyze the document's structure and content to understand therelationship between the document's structure and the document'scontent. The processes of retrieving a document, determining whether thedocument has any relevant chunks, and identifying and returning theserelevant chunks to the requesting user are collectively referred to asthe “upstream processes 35” as shown in FIG. 1.

FIG. 5 is a flowchart illustrative of how the stream engine 60 processescandidate documents retrieved from data sources 70 in accordance withsome embodiments.

After receiving the candidate document identifiers and optional pathfilters from the cache engine (502), the stream engine 60 startsretrieving the candidate documents identified by the documentidentifiers from respective data sources, including retrieving somecandidate documents from local data sources (504) and/or retrieving somecandidate documents from remote data sources (506). In some embodiments,local data sources include any storage devices affiliated with thecomputer system 100, such as hard disk and CD/DVD drives, and remotedata sources include any storage devices that can be accessed by thecomputer system 100 through wired and/or wireless network, such as a webserver on the Internet and/or a network storage device on the Intranet.

In some embodiments, a specific user instruction may limit the documentsearch to local or remote data sources. As shown in FIG. 16B, if theuser specifies that the type of the documents to be searched are Worddocuments, the stream engine 60 will retrieve only Word candidatedocuments from the local data source such as the local file system. Foreach candidate document identifier, the stream engine 60 submits arequest for the corresponding candidate document to the file system andwaits for the file system to return the candidate document. But if theuser clicks the checkbox next to a web source such as “Source A,” thestream engine 60 will retrieve the candidate documents identified bySource A from their respective remote web hosts. For example, if thecandidate document is an HTML document hosted by a web server, thestream engine 60 submits an HTTP request to the web server for the HTMLdocument and waits for an HTTP response including the HTML document fromthe web server. In some embodiments, the user instruction may explicitlyor implicitly request that candidate documents be retrieved from bothlocal and remote data sources.

In some embodiments, the stream engine 60 submits multiple requests fordifferent candidate documents in parallel or sequentially to therespective targeted data source(s). The candidate documents are thenretrieved from the respective data sources and processed by the streamengine 60 in parallel or sequentially. For illustration, the followingdescription in connection with FIG. 5 focuses on a single candidatedocument. But this by no means limits the present application toprocessing documents one by one sequentially. As will become moreapparent in connection with FIGS. 9A through 9B below, it is moreefficient to process multiple candidate documents from different datasources in parallel in some embodiments.

Referring again to FIG. 5, the stream engine 60 performs the followingoperations on each candidate document retrieved from a data source:

1. Convert the Candidate Document into a Node Stream (508);

To reduce the computer system 100's response latency, the stream engine60 starts converting immediately after receiving a portion of thecandidate document, without waiting for the entire candidate document tobe retrieved. A more detailed description of the conversion is providedbelow in connection with FIG. 8A.

2. Identify Candidate Chunks in the Node Stream (510);

As noted above, a candidate document includes one or more candidatechunks. A candidate chunk within the document, if identified assatisfying the user-specified search keywords, is usually more relevantto the user's search interest and therefore more useful to the user. Amore detailed description of this operation is provided below inconnection with FIGS. 8A and 9A.

3. Apply the Optional Path Filters to the Node Stream (512); and

For a user-specified search query, certain portions of the node streamare potentially relevant and other portions are completely irrelevant.It could be an efficiency gain if these irrelevant portions are excludedfrom further consideration. The path filters generated by the queryengine (operation 308 in FIG. 3) can be used to divide the node streaminto multiple node sub-streams, thereby eliminating the irrelevantportions of the node stream. In some embodiments, this procedure isoptional if the query engine 30 generates no path filter. A moredetailed description of the conversion is provided below in connectionwith FIGS. 10A-10B and 11A-11G.

4. Submit the Node Stream (or Sub-Streams) to the Cache Engine (514).

After performing the operations above, the stream engine 60 submits thenode stream or sub-streams to the cache engine 40. As will be explainedbelow in connection with FIG. 6, the cache engine 40 may or may not doanything depending on whether it needs to index the document representedby the node stream. If it does, the cache engine 40 invokes the indexdatabase 50 to generate new indexes or update existing indexes for thedocument. Otherwise, the cache engine 40 simply forwards the node streamor sub-streams to the query engine 30 for further processing, which isprovided below in detail in connection with FIGS. 8A-8C and 11A-11G.

FIG. 6 is a flowchart illustrative of how the cache engine 40 processesthe candidate documents coming out of the stream engine 60 in accordancewith some embodiments.

After receiving the node stream or sub-streams corresponding to acandidate document (601), the cache engine 40 performs differentoperations based on the type and status of the candidate document aswell as its destination. For example, if the candidate document is aWord document found in the local hard drive of the computer system 100and has not been indexed or its indexes are deemed stale, the cacheengine 40 will request that the index database 50 generate new indexesor update existing indexes for the candidate document (603). Dependingon whether the document is requested by an end user through the frontend 15 or a software agent monitoring the index database 50, the cacheengine 40 may or may not return the node stream to the query engine 30for further processing (605).

If the candidate document is an HTML document at a remote web server,which is identified through a third-party document source, it may beoptional to index the HTML document. If so, the node stream orsub-streams will be returned to and further processed by the queryengine 30 to determine whether it has any relevant chunk (605).

In sum, in some embodiments the cache engine 40 plays a relativelylightweight role in the upstream processes 35 especially if thecandidate document is retrieved from a remote data source to satisfy anend user's search request and the computer system 100 does not intend toindex the document. Therefore, some of the embodiments below assume thatthe stream engine 60 directly communicates with the query engine 30 forclarity.

FIG. 7 is a flowchart illustrative of how the query engine 30 identifiesrelevant chunks within the candidate documents in accordance with someembodiments.

Upon receipt of the node stream or sub-streams (e.g., path filtering atthe stream engine 60) (702), the query engine 30 traverses the nodestream and compares the candidate document's content with theuser-specified search keywords. If a match is found, the query engine 30identifies the candidate chunk within the document corresponding to thematch as one relevant chunk (704) and returns the identified chunk tothe front end 15 to be displayed to the end user (706).

In some embodiments (as shown FIG. 7), the query engine 30 returns anyrelevant chunk to the front end 15 as soon as the chunks are identifiedand this process repeats until the query engine 30 completely traversesthe candidate document (708). In some other embodiments, the queryengine 30 defers returning any chunk to the front end 15 until a morespecific relevant chunk is found in the node stream. A more detaileddescription of these two approaches is provided below in connection withFIGS. 8B and 8C, respectively.

As noted above, candidate documents arriving at the stream engine 60 areeach converted into a node stream. The node stream is an instance of adata model of the corresponding candidate document. For example, theXQuery data model of an XML document is a tree of nodes. The types ofthe nodes that appear at different hierarchical levels of the treeinclude: document, element, attribute, text, namespace, processinginstruction, and comment. Any node in the tree has a unique nodeidentity. The data model not only preserves the XML document's entirecontent but also has metadata derived from sources such as XML tags foridentifying candidate chunks subsequently.

Unfortunately, not all candidate documents are structured like an XMLdocument. For example, a plain-text document is completely unstructuredsuch that it does not have any metadata embedded therein defining ahierarchical structure for the document. Without any pre-processing, anode stream corresponding to the plain-text document loses the semanticinformation intrinsic in the content distribution of the document suchthat it is difficult to identify any chunk such as paragraph, headline,or title, within the node stream to satisfy a search query. PDFdocuments have similar problems that make it challenging to findrelevant chunks within a PDF document.

Between the structured XML documents and the unstructured plain-textdocuments are semi-structured documents such as HTML documents. Unlikethe plain-text document, an HTML document has a hierarchical structuredefined by metadata embedded in the HTML document. But the metadata inthe HTML document usually does not have a deterministic relationshipwith the content data as the metadata in an XML document has. The sameHTML tag can be used purely for web page layout purpose at one locationwhile carrying a semantic connotation at another location within thesame document.

To expedite the upstream processes and accommodate more types ofdocuments in the future, it is desired to have a unified approach suchthat different types of documents are processed in the same manner.

FIG. 8A is a flowchart illustrative of how the stream engine 60generates semantic data models for different types of documents inaccordance with some embodiments.

After receiving the raw data of a candidate document, the stream engine60 transforms the raw data into an instance of a data model ofstructured or semi-structured data (801). In some embodiments, thisoperation is straightforward if the candidate document is already astructured document like a Microsoft Office 2007 document. In some otherembodiments, this operation is necessary if the candidate is aplain-text document without any structure-related metadata. In thiscase, the stream engine 60 may insert metadata into the document thatdefines a hierarchical structure for the document's content.

Based on the class of the raw data (803), the stream engine 60 thenperforms different sets of operations to the data model instancegenerated previously. For example, as noted above, the candidatedocument may be classified into one of three categories:

-   -   unstructured documents (805-A) such as plain-text and PDF;    -   semi-structured documents (805-B) such as HTML and RTF; and    -   structured documents (805-C) such as XML and Office 2007.

For an unstructured document, the stream engine 60 applies a set ofnatural language and common formatting based heuristic rules to separatetext within the document into separate candidate chunks (807). Forexample, one heuristic rule for identifying paragraphs stipulates thatany two text segments separated by symbols such as an end-of-line (EOL)character or a blank line correspond to at least two separateparagraphs. Another heuristic rule stipulates that a text segmentmatching a predefined text pattern is deemed to be a candidate chunk.Consider the following text segment that has two hyphens, one at thestart of a new line:

-   -   This is a bullet list.    -   What about a page number?        In this case, each line by itself may be a candidate chunk        (although it may or may not be deemed to be a paragraph). The        fact that the two lines have the same text pattern, i.e., a        hyphen at the start of a new line followed by a text string, may        indicate that the entire text segment is a candidate chunk at        one level of the document's hierarchical structure and each line        is also a candidate chunk at a lower level of the hierarchical        structure.

Similarly, for a semi-structured document, the stream engine 60 hasanother set of heuristic rules based on the type of the semi-structureddocument (809). For a node stream corresponding to an HTML document, thestream engine 60 identifies candidate chunk break nodes within the nodestream both dynamically and statically.

For example, the <p> tag defines a paragraph within the HTML documentand it is deemed to be a candidate chunk break node. Whenever the <p>tag appears in an HTML document, the subsequent document segmentfollowing this <p> tag and before another <p> tag is identified as acandidate chunk.

Note that there are many ways of identifying chunk break nodes within asemi-structured document known to one skilled in the art. In someembodiments, the stream engine 60 applies different sets of customizedheuristic rules to different types of documents. For a structureddocument or a semi-structured document for which there is no customizedsolution, the stream engine 60 assumes that there is astrongly-deterministic relationship between the document's content andthe document's metadata and a generic set of rules is applied to thedata model instance to identify possible candidate chunks in thecandidate document.

By traversing the node stream, the stream engine 60 generates a datamodel instance for the candidate document that includes semanticannotation (811). Subsequently, the semantically-annotated node streamis fed into the query engine 30. The query engine 30 then applies asearch query to the node stream to identify among the candidate chunksany that satisfy the search query.

As noted above in connection with FIG. 7, the query engine 30 does nothave to wait until it traverses the entire node stream before returningany relevant chunk to the front end 15. Below are two embodiments of howthe query engine 30 returns identified chunks after a respectivecondition is met and before the entire node stream is traversed.

Assume that the search query has two keywords, “raining” and “data,” andthe exemplary candidate document is as follows:

<c0>   It's raining outside ...   <c1>     For XML-based datamanagement,     Raining Data is your choice.   </c1> </c0>

FIG. 8B is a flowchart illustrating a first embodiment of how the queryengine identifies a relevant chunk within a node stream representing acandidate document.

The query engine 30 starts the search after receiving a node streamcorresponding to the candidate document above (821). If no more nodesare in the node stream (823, no), the query engine 30 assumes that ithas completely traversed the node stream and the search stops (825).Otherwise, the query engine 30 processes the next node in the stream(827).

Before any further processing, the query engine 30 checks whether it isin the middle of accumulating nodes (829). In some embodiments, thequery engine 30 begins accumulating nodes after it encounters the chunkbreak node of the first candidate chunk in the node stream. In thisexample, the chunk break node of the first candidate chunk is the <c0>tag, which is the first node in the stream, and the accumulation has notstarted yet (829, no).

Next, the query engine 30 checks whether the node is a text node (839).Since the <c0> tag is not a text node (839, the query engine 30 updatesthe current node path to be “/c0” (841) and checks whether the currentnode is part of a candidate chunk (843). Because the <c0> tag is thechunk break node of the first candidate chunk (843, yes), the queryengine 30 marks the current node path as corresponding to a candidatechunk (845) and then starts node accumulation immediately (847).

Following the <c0> tag node, the next node to be processed by the queryengine 30 is a text node including “It's raining outside . . . .” Inthis case, because the accumulation has already started (829, yes), thequery engine checks if the text node is part of a relevant chunk (831).But since no search keyword has been matched so far (831, no), the queryengine 30 accumulates the text node (837). Because this is a text node(839, yes), the query engine 30 then checks whether it is in a candidatechunk (849).

In this case, the text node is in a candidate chunk (849, yes). Thequery engine applies the search query to the text node (851). Butbecause only the keyword “raining” finds a match in the text string,which is a partial match of the search query, no relevant chunk has beenfound yet (853, no) and the query engine 30 returns to process the nextnode in the sub-stream (823). In some embodiments, the query engine 30records the partial match result for subsequent use.

When the query engine 30 receives the second text node including thetext string “For XML-based data management,” it repeats the sameprocessing steps 827 through 853 described above. In this case, becausethe two text nodes in combination match both keywords, a relevant chunkand its associated node path “/c0/c1” are identified (855). Next, thequery engine 30 processes the third text node including the text string“Raining Data is your choice.” Because the third node is already in arelevant chunk (831, yes), the query engine 30 checks whether therelevant chunk is completed (833). In some embodiments, a chunk iscompleted if the query engine encounters a node including the end tag ofa candidate chunk, e.g., </c0> or </c1>.

In this case, because the query engine 30 has not seen any end tag yet(833, no), the process continues and the second and third text nodes incombination also match the two keywords because both the second andthird text nodes are within the second candidate chunk (<c1>, </c1>),which is a descendent of the first candidate chunk (<c0>, </c0>). Insome embodiments, if there is a hierarchical relationship betweenmultiple relevant chunks, the query engine 30 first completes therelevant chunk at the lowest level, which is also referred to as themore specific relevant chunk, and then outputs this more specificrelevant chunk to the front end 15 (835). In this example, the morespecific relevant chunk is

<c1>   For XML-based data management,   Raining Data is your choice.</c1>

Note that the query engine 30 does not necessarily stop after outputtingthe more specific relevant chunk (835). Rather, the query engine 30proceeds to the next node that includes the </c0> tag. As a result, theless specific relevant chunk (as will be described below in connectionwith FIG. 8C) is the next relevant chunk to be output.

In some embodiments, the query engine 30 outputs this relevant chunk tothe front end 15. As a result, the front end 15 may ultimately displaytwo relevant chunks to the end user. Alternatively, the front end 15 maycompare the two relevant chunks before displaying them and choose onlyone of them, e.g., the more specific one above or the second broaderone, to be displayed. In some other embodiments, the query engine 30 maychoose not to output the second relevant chunk to the front end 15 if itdetermines that the first one is sufficient to satisfy the end user'ssearch interest.

FIG. 8C is a flowchart illustrating a second embodiment of how the queryengine 30 identifies a relevant chunk within a node stream representinga candidate document. This embodiment is similar to the embodimentdescribed above in connection with FIG. 8C except that, after a relevantchunk is identified, the query engine 30 immediately starts outputtingnodes in the identified chunk (895) without waiting for the completionof the relevant chunk (835 in FIG. 8B). Moreover, the query engine 30also outputs subsequent nodes within the same relevant chunk (877), ifthere are any, without waiting for the completion of the relevant chunk(835 in FIG. 8B).

Using the same exemplary candidate document above, the query engine 30outputs the relevant query when it encounters the second text nodeincluding the text string “For XML-based data management” because bothsearch keywords have matches in the relevant chunk. Although thisrelevant chunk might not be as satisfactory as the more specific one,the response latency of this second embodiment is usually shorter thanthe response latency of the first embodiment.

As described above in connection with FIG. 5, the stream engine 60receives one or more candidate document identifiers such as URIs fromthe cache engine 40. For each URI, the stream engine 60 submits arequest to a respective data source to retrieve the correspondingcandidate document hosted by the data source. If multiple requests aresubmitted to different data sources within a short time period or evenin parallel, the requested candidate documents may arrive at the streamengine 60 simultaneously or nearly so.

In some embodiments, a candidate document such as a web page at a remoteweb server is divided into multiple data packets at the respective datasource and transmitted back to the stream engine 60 one packet at atime. But due to network traffic jams, the data packets from a singledata source may arrive at the stream engine 60 out of their originaltransmission order and the data packets from different data sources mayarrive at the stream engine 60 at different rates. The query engine 30,however, usually requires that the data packets of a particularcandidate document be analyzed sequentially to identify relevant chunkstherein and present them to the end user. This is especially true if atext node that satisfies a search query is larger than the maximum sizeof a packet and therefore has to be allocated into multiple data packetsfor network transmission.

As a result, such a deadlock situation often occurs: on the one hand,the stream engine 60 is waiting for a data packet from a first datasource to support the query engine 30's operation; on the other hand,the data packet cannot arrive at the stream engine 60 on time due tonetwork delay. At the same time, multiple data packets from a seconddata source may have arrived at the stream engine 60, but they arepostponed from further processing although they might contain a relevantchunk. If this issue is not appropriately resolved, it wouldsignificantly increase the computer system's response latency, causing aless satisfactory user experience to the end user.

FIG. 9A is a flowchart illustrative of how the stream engine 60processes multiple candidate documents to identify candidate chunks inaccordance with some embodiments. For illustration, assume that thestream engine 60 receives two URIs, UA and UB, from the cache engine 40,each identifying a candidate document at a respective data source. Inreality, the stream engine 60 may receive N URIs and therefore process Nnode streams at the same time, N being an integer number varying from afew to a few hundred.

Initially, whenever it has bandwidth for processing more URIs (902,yes), the stream engine 60 checks whether there are any URI availablefor processing (904). If not (904, no), the stream engine 60 processesexisting node streams (912). In this example, both UA and UB areavailable (904, yes). The stream engine 60 chooses one of them (906),e.g., UA, and checks the availability of the corresponding data source(908). If the data source is not available (908, no), the stream engine60 then returns to process the next URI (902). Otherwise (908, yes), thestream engine 60 generates a node stream for UA (910) and then returnsto process the next URI (902). At the end, for each candidate document,the stream engine 60 generates a node stream to manage incoming datapackets corresponding to the document.

In some embodiments, the stream engine 60 checks the availability of adata source repeatedly until a predefined condition is met, e.g., thetime elapsed from the first check to the last check is beyond athreshold level. If no, the stream engine 60 assumes that thecorresponding document is not available and devotes its resources toprocessing other available candidate documents. Note that the streamengine 60 may perform the same or similar exercise repeatedly for eachdata source from which it has already received data packets. If thestream engine 60 fails to receive any data packet from a data source fora predefined time period, the stream engine 60 may assume that this datasource is no longer available and free any resources allocated for thisdata source and the corresponding node stream. By doing so, the overallresponse latency is below a level of reasonable tolerance.

In this example, assume that the stream engine 60 chooses to work on oneof the two available node streams (902), e.g., the UA node stream, andthe first data packet has arrived (916). The stream engine 60 processesthe data packet (920), such as verifying its accuracy, extracting theraw data of the candidate document from the data packet, and convertingthe raw data into one or more nodes in the UA node stream. Next, thestream engine 60 parses the next node in the UA node stream (922) toidentify candidate chunks within the node stream.

For each node in the UA node stream, the stream engine 60 determines ifit corresponds to a new candidate chunk (926) or is within an existingcandidate chunk (928) until finishing the last one in the node stream(924). In either case (926, yes) (928, yes), the stream engine 60accumulates the node into the candidate chunk (930) and then determineswhether it has reached the end of the corresponding candidate chunk. Ifso (932, yes), the stream engine 60 sends the candidate chunk to thequery engine 30 for further processing (934), e.g., determining whetherthe candidate chunk is a chunk relevant to the user-specified searchkeywords.

In some embodiments, after sending the candidate chunk to the queryengine 30, the stream engine 60 returns to parse the next one in thenode stream (922) and repeats the aforementioned operations until itexhausts the last one in the node stream. In other words, the streamengine 60 and the query engine 30 may proceed in parallel andindependently. This mechanism or the like can be very efficient if thecomputer system 100 has enough resources, e.g., multiple processors(including co-processors) and/or a large amount of memory, or ifdifferent components within the computer system 100, e.g., the streamengine 60 and the query engine 30, operate on separate threads and thereis a carefully-maintained thread boundary between the two.

In some other embodiments, the stream engine 60 pauses after passing onecandidate chunk to the query engine 30 (934) and resumes processing thenode stream after it receives feedback from the query engine 30 (936).This mechanism or the like may be more feasible if the computer system100 has limited resources, e.g., a single processor and/or limitedmemory. In this case, the stream engine 60 and the query engine 30 sharethe same thread. As a result, the computer system 100 may only need asmall amount of memory to have a reasonably efficient performance. Amore detailed description of this feedback-based scheme is providedbelow in connection with FIGS. 10A-10B and 11A-11G.

As noted above, a candidate chunk is semantically and contextually aunit within a candidate document. The process described above inconnection with FIG. 8A may annotate multiple nodes in a node stream,each annotated node corresponding to a candidate chunk. These candidatedocuments may be associated with different levels of a hierarchical datamodel of the candidate document. In other words, a small candidate chunkcan be a descendant of a large candidate chunk.

FIG. 9B is an exemplary HTML document to be processed by the streamengine as shown in FIG. 9A in accordance with some embodiments. Fromapplying the corresponding heuristic rules to this HTML document, thestream engine 60 identifies nine candidate chunks 942 through 958. Notethat the first node within each candidate chunk is highlighted in FIG.9B. For example, the first node of the candidate chunk 942 is the<table> tag 960 and the first node of the candidate chunk 956 is the <p>tag 974. The candidate chunk 956 and the candidate chunk 958 are at thesame level in the hierarchical data model, both of which are descendantsof the larger candidate chunks such as the candidate chunk 954.

When applying the process in FIG. 9A to the HTML candidate document inFIG. 9B, the stream engine 60 receives the node including the <table>tag 960 and a new candidate chunk 942 is found (924, yes). Subsequently,the stream engine 60 receives the node including the <td> tag 962 andanother new candidate chunk 944 is found (924, yes). When the streamengine 60 receives the </p> tag 976, the first complete candidate chunk956 is found (930, yes) and the stream engine 60 sends the candidatechunk 956 to the query engine 30 (932). Similarly, when the streamengine 60 reaches the </p> tag 980, the second complete candidate chunk958 is found (930, yes) and sent to the query engine 30 (932). When thestream engine 60 reaches the </td> tag 982, the third complete candidatechunk 954 is found (930, yes) and sent to the query engine 30 (932).Note that the candidate chunk 954 is the parent of the two candidatechunks 956 and 958 and the candidate chunk 954 does not have any contentoutside the two descendant candidate chunks 956 and 958. As will beexplained below, the query engine 30 identifies the candidate chunk 954as the relevant chunk if the two descendant candidate chunks 956 and 958in combination satisfy the user-specified search keywords.

Assume that the stream engine 60 has processed the last node in the UAnode stream, which is one of multiple data packets occupied by a largeparagraph in the corresponding candidate document, and the stream engine60 has not received the last of the multiple data packets yet. In thiscase, because there are no more nodes in the UA node stream (922, no),the stream engine 60 returns to process the next URI (902). But as notedabove, there are no more URIs available (904, no) because the streamengine 60 receives only two URIs from the cache engine 40 and it hasalready generated a node stream for each URI. The stream engine 60 thenhas to choose between the UA node stream and the UB node stream (912).

If the stream engine 60 chooses one of the two node streams, e.g., theUA node stream, and for some reason the next data packet associated withthe UA node stream has not arrived at the stream engine 60 after acertain time (918, no), the stream engine 60 then returns to performoperation 902. In some embodiments, the stream engine 60 does notrandomly choose the next available node stream. Rather, it compares theavailable node streams and selects one node stream that has one or moredata packets waiting to be processed (912). By doing so, the streamengine 60 effectively reduces the risk of running into the deadlocksituation described above, which blocks the query engine 30 fromidentifying and serving relevant chunks from a different node stream.

For example, after finishing the last node in the UA node stream, thestream engine 60 may choose the UB node stream (912) and start searchingfor candidate chunks within the UB node stream until (i) the UB nodestream is completed (914, no) or (ii) there is a network traffic jamwith the UB node stream (924, no). In either case, the stream engine 60repeats the same process described above to work on the UA node streamif it has newly received data packets and there is still time forprocessing the node stream for a given response latency threshold.

In some embodiments, as noted above, a feedback mechanism (936, FIG. 9A)is established between the stream engine 60 and the query engine 30. Thedescription above illustrates the activities on the stream engine side.The description below in connection with FIGS. 10 and 11 focuses on thequery engine side, in particular, how the query engine 30 works inconcert with the stream engine 60 to identify relevant chunks inresponse to a search request.

FIG. 10A is a block diagram illustrative of how a query mediatorcoordinates the query engine 30 and the stream engine 60 to identifychunks within a node stream representing a candidate document inaccordance with some embodiments.

As described above, upon receiving a search query, the query engine 30may generate one or more path filters (308, FIG. 3), the path filtersare passed down to the stream engine 60 by the cache engine 40 (411,FIG. 4), and the stream engine 60 then applies the path filters to anode stream (512, FIG. 5). FIG. 10A depicts these processing steps in aslightly different manner.

Upon receiving the search query, the query engine 30 performs queryprocessing 1010 to define a set of input sequences 1015 for the searchquery. The set of input sequences 1015 further defines one or more pathfilters, which are used to build a filter model 1020. In someembodiments, as described below in connection with FIG. 10B, the filtermodel 1020 is the same or similar to a deterministic finite statemachine (FSM).

In addition to defining the path filters, the query engine 30 iteratesthe input sequences 1015 and their associated node sub-streams toidentify relevant chunks. Initially, because the query engine 30 has notreceived anything from the stream engine 60, a data request is submittedto the query mediator 1025. The query mediator 1025 is auser-configurable tool through which the user can, e.g., specify themaximum number of nodes in memory at any given time and control the rateof node stream consumption by the query engine 30.

In some embodiments, as the query engine 30 iterates each input sequence1015 and its associated node sub-stream, it determines whether a desirednode is currently in memory. If not, the query engine 30 asks the querymediator 1025 for the desired node until one of the predefinedconditions is met. These conditions include: (i) another context nodefor the input sequence is available; (ii) another fragment or contentnode of the current context node is available; and (iii) the currentcontext node is complete. A more detailed description of context nodesis provided below in connection with FIGS. 11A through 11G.

In response to the data request, the query mediator 1025 triggers thestream engine 60 for further conversion of raw data into the node stream1030. As a result, more nodes are submitted to the filter model 1020.The filter model 1020 feeds these nodes into the finite state machine itbuilds using the path filters to accumulate those nodes matching thepath filters in their respective sub-streams until one of the predefinedconditions is satisfied. By then, the query mediator 1025 passes thecontrol back to the input sequences 1015 and therefore the query engine30, which analyzes the node sub-streams to identify relevant chunks.

In sum, this feedback mechanism between the stream engine 60 and thequery engine 30 ensures that a minimum number of nodes are stored in thecomputer system 100's memory and processed by the query engine 30 tofulfill the search query, and that this process is accomplished withoutloss of any raw data.

FIG. 10B is a flowchart illustrative of how the stream engine 60 dividesthe node stream into multiple sub-streams using a filter model inaccordance with some embodiments.

Using the path filters provided by the query engine 30, the streamengine 60 generates a finite state machine (1034). The input to thefinite state machine is a node stream corresponding to the raw data of acandidate document and the output is one or more node sub-streams, eachnode sub-stream including a set of nodes that may be potentiallyrelevant to the search query. Thus, the finite state machine effectivelyfilters out nodes that are deemed to be completely irrelevant to thesearch query and reduces the amount of data to be handled by the queryengine 30. Next, the stream engine 60 receives the next node in the nodestream (1036) and compares the node with the finite state machine (1038)to determine if the node belongs to one or more node sub-streamsassociated with the path filters.

In some embodiments, the finite state machine performs differentoperations in accordance with different comparison results. For example,the finite state machine may: (i) perform a transition operation(1040-A) and move itself from the current state to a different one thatis associated with the node (1042); (ii) perform a maintenance operation(1040-B) and stay at the current state (1044); or (iii) perform a nulloperation (1040-C) and discard the node as irrelevant to the searchquery (1046). In the last case, the finite state machine may also stayat the current state.

After performing a transition/maintenance operation, the stream engine60 accumulates the node into a respective node sub-stream (1048).Depending on whether the node is a context node (1050-A) or a contentnode (1050-B), the stream engine 60 may insert the node into the contextnode sub-stream (1052) or insert the node into a node sub-stream that isassociated with the current context node (1054). A more detaileddescription of this accumulation operation is provided below inconnection with FIG. 11E. Next, the stream engine 60 determines whetherthe node stream is completed (1056). If so (1056, yes), the streamengine 60 sends the node sub-streams to the query engine 30 for furtherprocess (1058). Otherwise (1056, no), the stream engine 60 returns toprocess the next node in the node stream (1036).

To further explain the feedback mechanism between the stream engine 60and the query engine 30, FIGS. 11A through 11G illustrate in detail howa candidate document is processed using the feedback mechanism.

FIG. 11A is an exemplary XML document 1100 to be processed by the streamengine 60 and the query engine 30 in accordance with some embodiments.The XML document 1100 includes a list of books 1102 through 1108, eachbook being identified by its publication year (the “year” attribute inthe <book> tag), its title (the pair of <title> and </title> tags), itsauthor (the pair of <author> and </author> tags) including first name(the pair of <first> and </first> tags) and last name (the pair of<last> and </last> tags), its publisher (the pair of <publisher> and</publisher> tags), and price (the pair of <price> and </price> tags).

FIG. 11B is an exemplary XQuery 1110 to be applied to the XML document1100 in accordance with some embodiments. The XQuery 1110 searches forany book in the XML document “bib.xml” whose publisher is Addison-Wesleyand whose publication year is later than 1991. The XQuery 1110 requiresthat the search results be returned in the form of a new XML documentincluding a new list of the books matching the two search criteria, eachbook in the new XML document only including the book's title and itspublication year as an attribute in the <book> tag.

FIG. 11C is a table 1115 of the five input sequences defined by thequery engine 30 in accordance with some embodiments. Based on the XQuery1110, the query engine 30 defines five input sequences, each inputsequence corresponding to one tag or tag attribute within the XMLdocument 1100. Note that the publication year attribute “year” appearstwice in the XQuery 1110, one in the where clause and the other in thereturn clause, and corresponds to two separate input sequences. The fiveinput sequences each have an associated node sub-stream labeled “NodeSub-Stream (0)” through “Node Sub-Stream (4)” and correspond to arespective path filter as shown in the table 1115.

Different input sequences are associated with different portions of theXQuery 1110 and therefore have different modes. For example, the <book>tag associated with the input sequence “Node Sub-Stream (0)” appears inthe for-in clause, but not the return clause. Thus, the input sequence“Node Sub-Stream (0)” is presumed to provide context for the searchprocess and serve in the “Context” mode, and the nodes in thecorresponding node sub-stream are referred to as “context nodesub-stream.”

Similarly, the content of the <publisher> tag associated with the inputsequence “Node Sub-Stream (1)” is compared with “Addison-Wesley” in thewhere clause of the XQuery 1110. Thus, the input sequence “NodeSub-Stream (1)” is presumed to provide content for the search processand serve in the “Content” mode, and the nodes in the corresponding nodesub-stream are therefore referred to as “content node sub-stream.” The<title> tag associated with the input sequence “Node Sub-Stream (4)”appears in the return clause. Thus, the input sequence “Node Sub-Stream(4)” is presumed to provide both context and content for the searchprocess and serve in the “All” mode. In some embodiments, an inputsequence in the “All” mode has two node sub-streams.

The “Parent” column in the table 1115 indicates whether an inputsequence is a child of another input sequence. In this example, theinput sequence associated with the for-in clause provides basis for theother input sequences associated with the other parts of the XQuery1110. Any node in one of the other four input sequences corresponds to aspecific node in the input sequence “Node Sub-Stream (0),” which istherefore deemed to be the parent input sequence of the other four inputsequences.

FIG. 11D is a flowchart illustrative of how the query engine 30processes node sub-streams at different input sequences in accordancewith some embodiments. This flowchart provides more details of theinformation flow shown in the block diagram of FIG. 10A.

The query engine 30 initializes the stream engine 60 (1120) andprocesses the search query (1122) to define input sequences, pathfilters, and a finite state machine that is used for generating one ormore node sub-streams. The query engine 30 then starts iterating thenext node sub-stream (1124). In this example, the query engine 30 beginswith the context node sub-stream of Node Sub-Stream (0).

If the context node sub-stream has no context node (1126, no), the queryengine 30 then requests more context nodes from the stream engine 60(1128, 1130). Consequently, more data packets are retrieved (1132) andparsed (1134) to provide more nodes, including context nodes and contentnodes, to the query engine 30.

Once a new context node is present in the node sub-stream of NodeSub-Stream (0) (1126, yes), the query engine 30 applies the search queryto the context node and its associated nodes in other node sub-streams(1136). If the search criteria are satisfied (1138, yes), a relevantchunk has been identified and there is no need to apply the search queryto the remaining portion of the relevant chunk. Thus, the query engine30 needs to quickly reach the end of the relevant chunk throughround-tripping the content nodes in different node streams (1140). Afterfinishing the content nodes, if the end of the chunk has not beenreached (1142, no), the query engine 30 may request the stream engine 60to process more data packets (1146).

If the search criteria are not met (1138, no), a relevant chunk has notbeen identified, and the query engine 30 sends a request to the querymediator to retrieve one or more content nodes and re-apply the searchquery. If the stream engine 60 has more nodes or node fragments (1144,yes), they will be parsed and submitted to the query engine 30 (1134).Otherwise (1144, no), the query engine 30 may request the stream engine60 to process more data packets (1146).

As shown in FIG. 11C, the XQuery 1110 defines five input sequences andtherefore five path filters. The stream engine 60 uses these pathfilters to build a finite state machine, which, as shown in FIG. 10B, isto divide the original node stream corresponding to the XML document1100 into five node sub-streams. The finite state machine has an initialstate, which can be any one of the five input sequences.

FIG. 11E is a block diagram illustrative of how the node stream isdivided into multiple node sub-streams by the finite state machine inaccordance with some embodiments. From the start state (1150), thefinite state machine receives a node including the <bib> tag. Becausethis tag is not relevant to any input sequence, the finite state machinediscards the node. After receiving a node including the <book> tag, thefinite state machine makes a transition to the state corresponding toNode Sub-Stream (0) and adds the node into the corresponding contextnode stream (1152). Next, the node including the publication yearattribute is processed and added into the two respective nodesub-streams corresponding to Node Sub-Stream (2) and Node Sub-Stream (3)(1154).

Upon receiving a node including the <title> tag, the finite statemachine makes another transition to the state corresponding to NodeSub-Stream (4). As noted above in connection with FIG. 11C, the inputsequence Node Sub-Stream (4) serves in the “All” mode. Thus, besidesadding the node including the <title> tag into the corresponding nodesub-stream (1156), the finite state machine adds everything enclosed bythe pair of (<title>, </title>) tags into the same node sub-stream or aseparate node sub-stream (1158). For example, if there is a pair of(<subtitle>, </subtitle>) tags within the pair of (<title>, </title>)tags, they will be added into the respective node sub-stream because, asexplained above, the XQuery 1110 requires the return of each matchingbook's title, including its subtitle, if present.

Similarly, the node including the <publisher> tag is added into the nodesub-stream corresponding to Node Sub-Stream (1) (1160) and the textualportion within the pair of (<publisher>, </publisher>) tags is extractedby a text( ) function and added into the same or a separate nodesub-stream (1162). This textual portion is required by the XQuery 1110to check whether the book is published by the publisher Addison-Wesley.

FIG. 11F is a block diagram illustrative of the input sequences andtheir associated node sub-streams after the first candidate chunk in theXML document is processed in accordance with some embodiments.

The node sub-stream “Node Sub-Stream (0)” is first populated with acontext node “<book>” (1164). Next, the node sub-streams “NodeSub-Stream (2)” and “Node Sub-Stream (3)” are each populated with acontent node “1994” (1166, 1168). For the node including the <title>tag, the stream engine 60 inserts into the node sub-stream “NodeSub-Stream (4)” both the <title> tag (1170) and the data descending fromthe <title> tag (1172). For the node including the <publisher> tag, thestream engine 60 is only interested in its content and thereforepopulates the node sub-stream “Node Sub-Stream (1)” with the textualportion of the <publisher> tag (1174).

FIG. 11G is the search result of applying the XQuery 1110 to the nodesub-streams derived from XML document 1100 in accordance with someembodiments. The search result is also an XML document 1180 thatincludes two books 1182 and 1184 that satisfy the XQuery 1110. As shownin FIG. 11F, the node sub-streams corresponding to the five inputsequences include all information necessary for generating thisresulting XML document 1180.

Thus far, detailed descriptions of document-processing schemes inresponse to a search request, including the downstream processes 25 andthe upstream processes 35, are provided above. These document-processingschemes can be used to implement various applications to satisfydifferent user needs. For illustration, embodiments of representativeapplications are provided below.

One application of the invention is to improve a user's experience withthe search results generated by search engines. Although a documentidentified by the search results is relevant to the search keywords, thedocument may not include any relevant chunks because the search enginestreat the entire document, not a chunk within the document, as the basicunit to be compared with the search keywords. Thus, one aspect of theinvention is to identify and display relevant chunks within a documentin response to a search request.

FIG. 12A is a flowchart illustrative of a first process of identifyingone or more documents, each document having one or more chunks thatsatisfy user-specified search keywords, in accordance with someembodiments.

A computer identifies multiple resource identifiers (1201), eachresource identifier corresponding to a document at a respective datasource. In some embodiments, a resource identifier is a URL, whichidentifies a web page at a remote web server. In some embodiments, theresource identifiers are part of search results produced by a servercomputer such as a search engine in response to one or more searchkeywords provided by an end user from a client computer.

For at least one of the resource identifiers, the computer retrieves thecorresponding document from the respective document source (1203). Ifthe document is a web page hosted by a web server, the computer submitsan HTTP request to the web server and the web server returns thedocument in an HTTP response. Within the retrieved document, thecomputer identifies a chunk that satisfies the user-specified searchkeywords (1205) and displays the identified chunk and a link to theidentified chunk within the document to the user (1207).

FIG. 12B is a flowchart illustrative of a second process of identifyingone or more document, each document having one or more chunks thatsatisfy user-specified search keywords, in accordance with someembodiments.

A client computer submits one or more user-specified search keywords toa server computer (1211). In some embodiments, the server computer isone or more third-party search engines. The client computer receives aset of search results from the server computer (1213), each searchresult identifying a document located at a respective document sourcethat satisfies the search keywords in accordance with a first set ofpredefined criteria.

For each identified document, the client computer retrieves the documentfrom the corresponding document source (1215), identifies a chunk withinthe document that satisfies the search query in accordance with a secondset of predefined criteria (1217), and displays the identified chunk anda link to the identified chunk within the document (1219). In someembodiments, the two sets of predefined criteria are different. Forexample, the first set of criteria requires that all the search keywordsbe found within a document, but not necessarily within a chunk. Incontrast, the second set of criteria is satisfied only if all the searchkeywords are found within a chunk.

FIGS. 12C through 12J are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 12A and 12B in accordance with some embodiments.

The graphical user interface includes one or more document links, eachdocument link having one or more associated chunks identified within thecorresponding document as satisfying one or more user-specified searchkeywords. In some embodiments, each chunk has an associated chunk linkand includes terms matching each of the user-specified search keywords.The matching terms may also be highlighted in the chunk in a visuallydistinguishable manner (such as in different colors, font types orcombination thereof). In response to a user selection of a chunk's chunklink, the corresponding document is displayed in a window on thecomputer display and at least a portion of the chunk is highlighted inthe window.

In some embodiments, each document link has an associated chunkpage-link icon for searching chunks within documents that are referencedby the corresponding document. In response to a user selection of adocument link's associated chunk page-link icon, one or more referenceddocument links are displayed on the computer display, with eachreferenced document link having one or more associated chunks identifiedwithin a corresponding referenced document as satisfying theuser-specified search keywords.

In some embodiments, each document link has an associated hide-chunkicon. In response to a user selection of a document link's associatedhide-chunk icon, the chunks associated with the document link and theirassociated chunk links disappear from the computer display.

In some embodiments, chunks associated with a respective document linkare displayed in an order consistent with their relative relevancy tothe user-specified search keywords. In some other embodiments, chunksassociated with a respective document link are displayed in an orderconsistent with their relative locations within the correspondingdocument.

As shown in FIG. 12C, through an application 1220 (e.g., a web browserwindow), a user submits three search keywords 1221 from a clientcomputer to a content provider such as a search engine. In this example,the application 1220 provides four different search options for the userto choose. They are:

-   -   “Best Match” option 1226-A—This search option allows the        application 1220 to adaptively select one or more chunks        satisfying one or more of the user-specified search keywords        according to predefined criteria. In some embodiments, the “Best        Match” option is the default option if the user does not        expressly choose a different one. A more detailed description of        this search option is provided below in connection with FIGS.        21A through 21D.    -   “Match All” option 1226-B—This search option limits the search        results to relevant chunks that satisfy each of three        user-specified search keywords. Thus, a candidate chunk that        only includes “einstein” and “bohr,” but not “debate,” should        not be in the search results responsive to the “Match All”        option, but may be in the search results responsive to the “Best        Match” option. As shown in FIG. 12C, the user expressly chooses        the “Match All” option.    -   “‘Exact’ Match” option 1226-C—This search option further limits        the search results to relevant chunks that not only satisfy each        of three user-specified search keywords, but also include an        exact match of the search keywords as a string. Examples of        “exact”-matching chunks are shown in FIGS. 12F and 12G,        respectively. Note that this option is different from the        string-match approach, which is variant-sensitive. Under the        string-match approach, “einstein bohr debates” does not match        “Einstein-Bohr debate.” But according to the “‘Exact’ Match”        option, the two sets of terms do match each other as this search        option ignores any non-word characters such as white space,        punctuation, etc., and only requires that the three terms appear        in the same order and have no intervening terms.    -   “Match Any” option 1226-D—This search option allows the        application 1220 to identify and display any chunk that        satisfies at least one of the user-specified search keywords.        Thus, the search results responsive to any of the three options        above are a subset of the search results responsive to the        “Match Any” option, an example of which is depicted in FIGS. 12I        and 12J.

The content provider returns a search result 1225 to the client computerand the search result 1225 includes an abbreviated document segmentidentified by the search engine as satisfying the search keywords. Theclient computer retrieves a document identified in the search result1225 (an HTML web page in this example) from a web server and identifiesone or more chunks 1229-A through 1229-C therein that satisfy the searchkeywords 1221, each chunk having an associated link 1231 to the chunk inthe original web page. In some embodiments, each of the chunks 1229-Athrough 1229-C are different from the abbreviated document segmentbecause it is a semantically and contextually consistent unit within thedocument without abbreviation.

In some embodiments, after retrieving a candidate document, theapplication 1220 generates a search query using the search keywords andapplies the search query to the retrieved document to identify relevantchunks within the document.

In some embodiments, the terms that match the search keywords in theidentified chunk are ordered differently from the user-specified searchkeywords. For example, the term “debate” appears between “Bohr” and“Einstein” in the chunk 1229-B of FIG. 12C.

In some embodiments, the terms that match the search keywords in theidentified chunk are separated from one another by at least one term notmatching any of the search keywords. For example, the three termsappearing in the last sentence of the chunk 1229-A are separated fromone another by many other words. Unlike the conventional string search,an identified chunk may or may not include an exact match of the searchkeywords as a string. Rather, the search process according to someembodiments of the invention includes tokenization of the searchkeywords in a text string into atoms and subsequent search in the tokenspace according to the atoms, which is variant-agnostic by, e.g.,ignoring things like grammatical tense, punctuation, white space,casing, diacritics, etc. in the search keywords. For example, in thescreenshot of FIG. 12C, “Einstein Bohr debate” and “einstein bohrdebating” are deemed to be identical according to some embodiments ofthe invention.

In some embodiments, an identified chunk includes an identical instanceof the search keywords appearing as a phrase. But, as noted above,although the instance is the same as the result of a string search, thesearch keywords are not identified collectively as a text string withinthe chunk.

In some embodiments, different terms matching different search keywordsin the identified chunk are highlighted in different manners such asdifferent colors, different foreground/background patterns, differentfont types/sizes, or a combination thereof. In FIG. 12C, the three termsappearing in each chunk are highlighted using large, italic, andunderlined font. In some embodiments, the three terms are furtherdistinguished from one another using a unique style for each term. Forexample, the three terms may have three completely different styles suchas Courier New for “Einstein,” Arial for “Bohr,” and Monotype Corsivafor “debate.” In some other embodiments, the three terms may havedifferent background colors, such as gray for “Einstein,” green for“Bohr,” and yellow for “debate.” In yet some other embodiments, thedifferent manners may be combined to further distinguish differentsearch keywords appearing in the same chunk.

In some embodiments, one or more sponsored links (1227, FIG. 12C) areidentified to be associated with at least one of the search keywords anddisplayed adjacent the identified chunk.

As shown in FIG. 12C, there are a chunk page-link icon 1223 and ahide-chunk icon 1224 below the search result 1225. In response to a userselection of the chunk page-link icon 1223, the computer retrievesdocuments that are referenced by the document identified by the searchresult 1225 and therefore have page links in the document. For eachretrieved document, the computer identifies chunks within the documentthat satisfy the search keywords 1221 by apply the same “chunking”process that has been applied to the document identified by the searchresult 1225.

FIG. 12D is a screenshot illustrative of the search results after a userselection of the chunk page-link icon 1251, including a link 1253-A,1253-B to a respective document and a set of relevant chunks 1255-A,1255-B identified within the corresponding document. The terms thatmatch the search keywords are similarly highlighted in the relevantchunks. Note that a user can repeat this process by clicking the chunkpage-link icons 1254-A, 1254-B associated with the respective documents.In some embodiments, the application 1220 applies its default searchoption, e.g., “Best Match” option 1226-A, for performing the taskassociated with the chunk page-link icon 1251. In some otherembodiments, the user can override the default search option byexpressly selecting another option.

FIG. 12E is a screenshot illustrative of the search results after theuser clicks the hide-chunk icons (1224, FIG. 12C) associated with therespective search results. In this example, the relevant chunksassociated with a search result disappear from the web browser windowand the hide-chunk icons become show-chunk icons 1257A, 1257B. Therelevant chunks are displayed again in the web browser window after auser selection of the show-chunk icons.

In some embodiments, multiple relevant chunks are identified within acandidate document and these chunks are displayed in an order consistentwith their relative locations within the document. FIG. 12F is ascreenshot that includes multiple relevant chunks, each one satisfyingthe two search keywords “Bohr-Einstein” and “debates.” These chunks arelisted in the web browser window in accordance with their relativelocations in the web page such that the first chunk 1233-A that appearsfirst in the web page is displayed above the other ones and the lastchunk 1233-B that appears below the other chunks is displayed at thebottom of the web browser window.

In some embodiments, multiple relevant chunks are identified within acandidate document and these chunks are displayed in an order consistentwith their relative relevancy to the search keywords. FIG. 12G isanother screenshot that includes the same set of relevant chunks. Assumethat the chunk 1233-B is more relevant than the chunk 1233-A. The morerelevant chunk 1233-B is displayed above the other less relevant chunksincluding the chunk 1233-A. For illustrative purposes, the twoscreenshots in FIGS. 12F and 12G are generated using the “‘Exact’ Match”option 1226-C. Each chunk 1233-A, 1233-B includes at least one instanceof the two search keywords as a string (ignoring the casing difference).The aforementioned chunk-ordering schemes or the like are equallyapplicable to the other search options.

In some embodiments, in response to a user selection of the link to anidentified chunk, at least a portion of the identified document isdisplayed in a document view window and the displayed portion includes,at least partially, the identified chunk. FIG. 12H is a screenshot ofthe web browser window after a user click of the chunk link 1235. Adocument view window 1237 is displayed next to the search results. Thedocument view window 1237 displays a portion of the document thatincludes the relevant chunk and the displayed portion includes at leastpart of the relevant chunk 1239 within the document. In this example,the relevant chunk 1239 is highlighted in the document view window.Sometimes, the terms matching the search keywords in the relevant chunk1239 are processed such that they are visually distinguishable over therest of the identified chunk, e.g., using different colors or fonttypes.

In some embodiments, for each relevant chunk in the identified document,the computer inserts a pair of unique chunk virtual delimiters into theidentified document. This pair of chunk virtual delimiters uniquelydefines the scope of the relevant chunk within the identified document,but is invisible to the user when the identified document is beingrendered by an application. In response to a user request to view therelevant chunk 1239 in the document view window 1237, the computer canquickly locate the scope of the relevant chunk 1239 within the documentby looking for the corresponding pair of chunk virtual delimiters andthen highlight the chunk in the document view window appropriately.

In some embodiments, the HTML tag <span> can be introduced into acandidate document for forming chunk virtual delimiters. For example,the following chunk in an HTML document

-   -   <p>This is a candidate chunk.</p>        can be re-defined as:    -   <span id=“chunk-1”><p>This is a candidate chunk.</p></span>

The HTML tag <span> has no effect on the appearance of the chunk in aweb browser window because it has no associated style information. Butthe pair of chunk virtual delimiters (<span id=“chunk-1”>, </span>)uniquely identifies the chunk's location in the document, which a webbrowser application can rely upon to highlight the chunk's existence by,e.g., altering its background color. Note that the HTML tag <span> isnot the only choice of a suitable invisible anchor element. In someother embodiments, it is possible to use one or more document-unique,chunk-unique identifiers or the like within the document as chunkvirtual delimiters to achieve the same or similar effect.

In some embodiments, for at least one of the resource identifiers, afterthe corresponding document is retrieved from the respective documentsource, no relevant chunk that satisfies each of the search keywords isidentified therein. This scenario happens if the terms matching thesearch keywords are distributed in different chunks within the document.In this case, the web browser window displays a link to search forchunks that satisfy any of the search keywords within the document. Inresponse to a user selection of the link to search for chunks thatsatisfy any of the search keywords within the document, the retrieveddocument is re-processed, and as a result, one or more chunks thatsatisfy at least one of the search keywords is identified in thedocument. Accordingly, these chunks are displayed to the end user.

FIG. 12I is a screenshot that includes a search result 1241 thatsatisfies all the search keywords “Einstein” and “big bang.” Because norelevant chunk is found in the web page, the web browser window providesa link 1243 to “re-chunk” the web page to search for any chunk matchingany search keywords. FIG. 12J is another screenshot after the user clickof the link 1243. Note that at least five chunks are identified in thedocument, three chunks 1245 including the keyword “Einstein” and twoother chunks 1247 including the keywords “big bang.” But no chunksatisfies all the search keywords. In some embodiments, the same set ofchunks can be identified in the document through a user selection of the“Match Any” option 1226-D.

Another application of the invention is to identify and display within adocument relevant chunks satisfying user-specified search keywords whilethe user is browsing the document. Conventionally, a user visiting a webpage may be only interested in the content of a particular paragraphtherein. To find the paragraph, the user-specified text string has toexactly match the one in the paragraph. Otherwise, the paragraph can notbe easily located in the document if the user can provide a few searchkeywords but is mistaken about their exact sequence in the paragraph.Such issues with the conventional approach have been solved by theapplication described below.

FIG. 13A is a flowchart illustrative of a first process of identifyingwithin a document one or more chunks that satisfy user-specified searchkeywords in accordance with some embodiments.

A computer displays a portion of a document to a user (1302). Uponreceiving a user-specified text string that includes multiple searchkeywords, the computer identifies a chunk within the document thatsatisfies the search keywords (1304) and displays the identified chunkto the user (1306). In some embodiments, the identified chunk is notwithin the initially displayed portion of the document. To locate thechunk, the computer generates a search query using the search keywordsand applies the search query to the document to identify the chunk. Insome embodiments, the terms that match the search keywords are eitherordered differently from the search keywords in the user-specified textstring or separated from one another by at least one term not matchingany of the search keywords.

FIG. 13B is a flowchart illustrative of a second process of identifyingwithin a document one or more chunks that satisfy user-specified searchkeywords in accordance with some embodiments.

While a user is browsing a document through a computer, the computerreceives multiple user-specified search keywords (1312). The searchkeywords have a first sequence. Within the document, the computeridentifies at least one chunk that satisfies the search keywords (1314)and displays a portion of the document including the identified chunk(1316). In some embodiments, the search keywords are highlighted in theidentified chunk and have a second sequence that is different from thefirst sequence.

FIGS. 13C through 13G are screenshots of a graphical user interface on acomputer display illustrative of features associated with the secondprocess as shown in FIGS. 13A and 13B in accordance with someembodiments.

FIG. 13C is a screenshot of a web page covering Bohr-Einstein debates atwww.wikipedia.org. Assuming that a visitor of this web page isinterested in learning about the experimental apparatus developed byGeorge Gamow, the visitor can enter a few search keywords relating tothis topic in the input field 1322 and then click the “Chunk Page” icon1323.

FIG. 13D is a screenshot of the web page including the identified chunk1326 that satisfies the user-specified search keywords 1324, i.e.,“gamow” and “experiment.” In this example, the relevant chunk 1326 isactually not a paragraph, but a caption of a figure in the document. Thesentence 1327 including the two keywords is read as follows: “GeorgeGamow's make-believe experimental apparatus for validating the thoughtexperiment . . . .” Although the two keywords are separated from eachother by other terms, the figure caption is identified nonethelessbecause the two keywords happen to be within the same chunk.

FIG. 13E is a screenshot illustrative of another embodiment of theinvention in response to a user selection of the “Chunk Page” icon atthe top of the web browser window. In this example, the left side of theweb browser window displays the relevant chunks 1325 identified withinthe web page. If the web page has multiple relevant chunks, the user caneasily get an overview of these chunks from the left side of the webbrowser. The right side of the web browser is a document view windowthat displays the portion of the document including the relevant chunk1326. Thus, this document view window provides more contexts for eachrelevant chunk to the user.

In some embodiments, like the examples described above in connectionwith FIGS. 12C through 12J, different terms in the identified chunk thatmatch different search keywords are highlighted in different mannerssuch as different colors, different foreground/background styles,different font types, or a combination thereof.

In some embodiments, multiple relevant chunks are identified within adocument, each one appearing at a respective location in the document.In this case, the web browser window displays, at least partially, thechunk that appears above the other chunks in the document and itsassociated context.

FIG. 13F is a screenshot of another web page at www.wikipedia.org. Inresponse to the user-specified search keywords 1328 “cosmic,”“background,” and “radiation,” the first relevant chunk 1330 in the webpage that matches the three search keywords is identified and displayedin a visually distinguishing manner. A scroll down of the web pagedisplays additional relevant chunks identified in the web page.

Sometimes, the first relevant chunk shown in FIG. 13F is not necessarilythe most relevant one. In some embodiments, after identifying multiplechunks within the document, the web browser assigns to each chunk aranking metric indicative of its relevancy to the search keywords anddisplays in a prominent location, at least partially, the chunk that hasthe highest ranking metric.

FIG. 13G is a screenshot of the same web page shown in FIG. 13F. But therelevant chunks are now displayed in an order consistent with theirrelevancy to the search keywords. In this case, the relevant chunk 1332is a section heading, which is presumably more relevant than the chunk1330 shown in FIG. 13F.

In some embodiments, if there is no chunk within the document thatsatisfies each of the search keywords, the web browser, or morespecifically, the “Chunk Page” toolbar application, may relax its searchcriteria to look for any chunks in the document that satisfy any of thesearch keywords and display them to the user. In other words, thisfeature is similar to the one described above in connection with FIGS.12I and 12J.

Another application of the invention is to identify relevant chunkswithin unstructured or semi-structured documents. It has been aparticular challenge to identify chunks within an HTML web page becausethe HTML syntax allows its user to produce the same or similar web pagelayout using very different metadata.

FIG. 14 is a flowchart illustrative of a process of modeling a documentand identifying within the document one or more chunks that satisfyuser-specified search keywords in accordance with some embodiments.

A computer identifies a document in response to a search request from auser (1401). The document includes content data and metadata, and thesearch request includes one or more search keywords. In someembodiments, the document is a semi-structured document, e.g., an HTMLweb page. The content data refers to the document's content such as aparagraph, a table, or a list of bullet items, etc. The metadataspecifies how the content data should be rendered through anapplication, e.g., a web browser window.

The computer generates a hierarchical semantic model of the content dataof the document by applying heuristics to the metadata of the document(1403). In some embodiments, the generation of the hierarchical semanticmodel includes identifying one or more candidate chunks in the document,each candidate chunk corresponding to a respective subset of thedocument. As noted above, the HTML web page shown in FIG. 9B has ahierarchical semantic model, which includes a set of HTML tags atdifferent levels.

In some embodiments, a first subset of the document associated with afirst candidate chunk encompasses a second subset of the documentassociated with a second candidate chunk. For example, as shown in FIG.9B, both the candidate chunks 956 and 958 are within the candidate chunk954, which is, in turn, within the candidate chunk 952. There is nooverlapping between the candidate chunk 956 and the candidate chunk 958.

In some embodiments, the heuristics stipulates that a subset of thedocument is identified as a candidate chunk if the subset of thedocument has at least one instance of predefined metadata. For example,the candidate chunks 956 and 958 are identified because each begins withthe <p> paragraph tag.

In some embodiments, the heuristics stipulates that a subset of thedocument is deemed to be a candidate chunk if the subset of the documenthas at least two instances of predefined metadata. For example, two ormore instances of the <li> tag appearing in a web page one after anotherare collectively identified as a candidate chunk.

The computer identifies a chunk within the document by sequentiallyscanning the hierarchical semantic model (1405). The identified chunkincludes a subset of the content data that satisfies the search keywordsand the corresponding metadata. The computer returns the identifiedchunk to the requesting user (1407).

In some embodiments, assume that there are two search keywords, a firstsearch keyword and a second search keyword. While sequentially scanningthe semantic model, the computer first identifies some content data thatis in the first candidate chunk and precedes the second candidate chunkas satisfying the first search keyword (e.g., “It's raining outside . .. ”) and then identifies content data in the second candidate chunk thatsatisfies the second search keyword (e.g., “For XML-based datamanagement”). Because both search keywords are matched, the firstcandidate chunk is chosen to be the identified chunk and returned to therequesting client.

In some embodiments, the computer does not return the first chunkimmediately after finding a match for the search keyword. Rather, thecomputer continues scanning the model until identifying content data inthe second candidate chunk that also satisfies the first search keyword(e.g., “Raining Data is your choice”). In this case, the secondcandidate chunk is returned as the relevant chunk that is more specificthan the first one.

In some embodiments, while sequentially scanning the hierarchicalsemantic model, the computer identifies content data that satisfies thefirst search keyword in one candidate chunk and content data thatsatisfies the second search keyword in another candidate chunk. Forexample, assume that the search keywords are “CAD” and “job listings.”As shown in FIG. 9B, the candidate chunk 956 includes the search keyword“CAD” and the candidate chunk 958 includes the search keyword “joblistings.” In this case, the computer chooses the candidate chunk 954,which is the parent of the chunks 956 and 958 in the hierarchicalsemantic mode, as the identified chunk. Note that there is no othercontent data or metadata within the candidate chunk 954 besides the twocandidate chunks 956 and 958.

Another application of the invention is to transform the user-specifiedsearch keywords into a finely-tuned query. Sometimes, the user-specifiedsearch keywords may include a special character (e.g., “%”) or sequenceof characters (e.g., “Jan. 22 2008”). This special character or sequenceof characters, if interpreted appropriately, can help to find therelevant chunks more efficiently.

FIG. 15 is a flowchart illustrative of a process of customizing a searchquery based on user-specified search keywords in accordance with someembodiments.

After receiving a search keyword provided by a user (1502), the computerselects an archetype for the search keyword (1504). The computeridentifies one or more search results in accordance with the archetype(1506) and returns at least one of the search results to the user(1508).

In some embodiments, the archetype has an enumerable set of instancesand the search keyword is associated with one of the instances. Forexample, if the user-specified search keyword is “Tuesday,” a possiblearchetype would be “week,” of which “Tuesday” represents one of theseven members in the archetype.

In some embodiments, after selecting the archetype, the computeridentifies at least one query operator for the selected archetype,constructs a search query using the query operator, and then executesthe search query against one or more data sources. For example, for the“week” archetype, the computer may generate a search query that looksfor chunks including not only the keyword “Tuesday,” but any of theseven days within a week such as “Sunday,” “Monday,” etc.

In some embodiments, the query operator has a scope and the search queryis constructed to limit search results within the scope. For example,assume that the search phrase is “discount of 10%.” It is likely thatthe user is not only interested in chunks having the phrase “discount of10%,” but also chunks having similar phrases, e.g., “discount of 15%.”Alternatively, the user may be mistaken when entering the phrase and thecandidate document actually has no chunk including the phrase “discountof 10%,” but does have chunks including the phrase “discount of 20%.” Inthis case, the computer may generate a search query for discount withinthe scope of 0% to 100%. As a result, more relevant chunks areidentified.

In some embodiments, the query operator has a pattern and the searchquery is constructed to limit search results including the pattern. Forexample, the user-specified phrase “Jan. 22, 2008” indicates a datepattern. If so, the computer may generate a search query accordingly tosearch for any chunk having the date pattern.

In some embodiments, after selecting the archetype and beforeidentifying the search results, the computer solicits user instructionsin connection with the archetype, constructs the search query inaccordance with the user instructions, and executes the search queryagainst the data sources. For example, if the user-specified searchkeyword includes the special character “%,” the computer may display auser interface through which the user may specify the scope or rangeassociated with that special character, which is then built into thesearch query.

In some embodiments, based on the user instructions, the computer maygenerate feedback to the user instructions and then receive more userinstructions in connection with the archetype and the feedback. Notethat this process may repeat for multiple loops until the user submits asearch query execution request, which suggests that the user issatisfied with the customized search query.

Another application of the invention is not only to display relevantchunks identified within a document but also to re-use them fordifferent purposes. For example, when a user composes a Word documentusing Microsoft Office, the user may like to view a slide in aPowerPoint document and, if needed, generate a copy of the slide in theWord document. Currently, there is no convenient way to do so other thanopening the PowerPoint document in a separate window, manually searchingfor the slide in the window, and manually copying the slide and pastingit into the Word document.

FIG. 16A is a flowchart illustrative of a process of displaying andre-using search results based on user instructions in accordance withsome embodiments.

A computer displays an application user interface (1601). Theapplication user interface includes a document authoring window and asearch results window. In response to a search request including one ormore user-specified search keywords, the computer displays in the searchresults window a set of search results in a text-only display format(1603). In some embodiments, each search result includes a chunk withina respective document that satisfies the search keywords. In response toa user request to view a chunk, the computer launches a document displaywindow in the application user interface and displays therein a portionof the corresponding document that includes the chunk in its nativedisplay format (1605). In response to a user request to duplicate asegment of the corresponding document in the document authoring window,the computer generates therein an instance of the segment of thecorresponding document in its native display format (1607).

FIGS. 16B through 16J are screenshots of a graphical user interface on acomputer display illustrative of features associated with the process asshown in FIG. 16A in accordance with some embodiments.

The application user interface includes a document authoring window anda search results window. A set of search results associated with one ormore user-specified search keywords is displayed in the search resultswindow in a text-only display format and each search result includes oneor more chunks identified within a respective document as satisfying theuser-specified search keywords. In response to a user request toduplicate a chunk within a document in the document authoring window, aninstance of the chunk is displayed in the document authoring window inthe document's native display format. In some embodiments, two chunksidentified within two different documents have different native displayformats.

In some embodiments, each chunk in the search results window has anassociated chunk link. In response to a user selection of a respectivechunk link, a document display window is displayed in the applicationuser interface and a portion of the corresponding document that includesthe corresponding chunk is displayed in the document display window inthe document's native display format.

In some embodiments, each chunk includes terms that match theuser-specified search keywords an associated chunk link. Different termsmatching different search keywords are highlighted in the search resultswindow in a visually distinguishable manner.

In some embodiments, the chunks identified within a document aredisplayed in the search results window in an order consistent with theirrelative relevancy to the user-specified search keywords. In some otherembodiments, the chunks identified within a document are displayed inthe search results window in an order consistent with their relativelocations within the corresponding document.

FIG. 16B is a screenshot of the Microsoft Office 2007 Word applicationuser interface 1611. The main region of the user interface is occupiedby a document authoring window 1613. Above the document authoring window1613 is an add-in 1615 to Microsoft Office 2007. The add-in 1615includes a keyword(s) input field 1615-A into which the user enterssearch keywords, a document type selection field 1615-B through whichthe user selects the types of candidate documents to be searched, and aweb source field 1615-C including multiple document sources throughwhich the user can search and re-use documents identified by therespective document sources.

In some embodiments, the set of search results includes a first chunkwithin a first document having a first content type and a second chunkwithin a second document having a second content type, wherein the firstcontent type is different from the second content type. Different searchkeywords in the search results window are highlighted in differentmanners.

FIG. 16C is a screenshot including a search results window 1625 and thesearch phrases 1621 “Einstein general relativity.” In this example, theuser limits the document search to two types of documents 1623, Word andPowerPoint. As described above in connection with FIG. 1, this searchlimit is passed down from the front end 15 (the add-in 1615 in thisexample) to the query engine 30 and then to the cache engine 40. Thus,the cache engine 40 only looks for Word and PowerPoint documents in theindex database 50. In this example, one chunk 1627 from a PowerPointdocument and another chunk 1629 from a Word document are shown in thesearch results window 1625.

Note that each chunk in the search results window has an associatedcontent type, which may be different from the document type of thecorresponding document that includes the chunk. For example, a Worddocument may include a PowerPoint slide or an Excel spreadsheet. If thePowerPoint slide is identified to be the relevant chunk, the contenttype of the relevant chunk is PowerPoint, not Word, although thePowerPoint slide is within a Word document. Similarly, if a row in theExcel spreadsheet is identified to be the relevant chunk and the contenttype of the relevant chunk is therefore Excel, not Word. These chunksmay or may not be displayed depending upon the embodiment.

In some embodiments, in response to a user request to duplicate thefirst chunk from the search results window into the document authoringwindow, the computer generates therein an instance of a first segment ofthe first document, including the first chunk, in its native displayformat. In response to a user request to duplicate the second chunk fromthe search results window into the document authoring window, thecomputer generates therein an instance of a second segment of the seconddocument, including the second chunk, in its native display format.Sometimes, the first document and the second document have differentnative display formats.

FIG. 16D is a screenshot including a PowerPoint slide 1633 in thedocument authoring window and the slide 1633 corresponds to the relevantchunk 1627 in FIG. 16C. To duplicate this slide 1633 in the documentauthoring window, the user first selects the checkbox 1631 next to thetext-only version of the slide in the search results window and thenclicks the duplicate icon 1635 at the top of the search results window.

FIG. 16E is another screenshot including not only the PowerPoint slide1633 but also a paragraph 1643, which corresponds to the relevant chunk1629 in FIG. 16C. To duplicate this paragraph 1643 in the documentauthoring window, the user first selects the checkbox 1641 next to thetext-only version of the paragraph in the search results window and thenclicks the duplicate icon 1645 at the top of the search results window.

Note that a PowerPoint document and a Word document are deemed to havedifferent native display formats. But relevant chunks in the searchresults window are displayed in a text-only format regardless of whetherthese chunks are identified within a PowerPoint document, a Worddocument, a plain-text document or even a PDF document. But when a chunkis duplicated into the document authoring window, the computer tries todisplay the chunk in its native format. Note that a chunk found in aplain-text or PDF document will be customized to a native display formatassociated with the document authoring window. In other words, if thedocument authoring window is a Word document authoring window, the chunkis displayed in the Word document's native display format.

In some embodiments, the user may like to display a relevant chunk inits native display format before re-producing the chunk in the documentauthoring window. For example, in response to a first user selection ofthe first chunk, the computer launches a first document display windowin the application user interface and displays therein a first documentthat includes the first chunk in its native display format. In responseto a second user selection of the second chunk, the computer launches asecond document display window in the application user interface anddisplays therein a second document that includes the second chunk in itsnative display format.

In some embodiments, the application user interface allows multipledocument display windows associated with different document types toexist simultaneously. In some other embodiments, at one time, theapplication user interface only allows one document display windowassociated with a document type, e.g., by closing the first documentdisplay window before launching the second document display window inresponse to the second user selection of the second chunk.

In some embodiments, in response to a user request to view the chunk,the computer generates an empty region in the application user interfaceby shrinking the document authoring window and then occupies the emptyregion with the document display window in the application userinterface.

In some embodiments, the portion of the corresponding document in thedocument display window includes more information about the searchkeywords than the chunk in the search results window, such as thelocation of the search keywords in the corresponding document or thetextual contents adjacent to the search keywords in the correspondingdocument.

FIG. 16F is a screenshot including a document display window 1653 in theprocess of being rendered within the application user interface inresponse to a user selection of the link 1651. Note that the link 1651is next to a chunk identified within a PowerPoint document. As shown inFIG. 16G, the corresponding slide 1657 is displayed in the documentdisplay window and its location 1659 is highlighted in the documentdisplay window.

After viewing a chunk in the document display window, the author maywant to duplicate the chunk in the document authoring window as well. Asshown in FIGS. 16H-16J, respectively, in response to a user request tocopy and paste a segment 1657 of the first document from the firstdocument display window into the document authoring window, the computergenerates therein an instance 1661 of the segment of the first documentin its native display format; in response to a user request to copy andpaste a segment 1663 of the second document display window into thedocument authoring window, the computer generates therein an instance1665 of the segment 1663 of the second document in its native displayformat. This process is similar to the process described above inconnection with FIGS. 16D and 16E.

In some embodiments, the document display window is a preview-onlywindow of the corresponding document (e.g., a PDF document). The usercannot modify the document through the preview-only window. In someother embodiments, the document display window itself is a documentauthoring window, which may be another instance of the documentauthoring window (see, e.g., FIG. 16I) or may be different from theoriginal document authoring window (see, e.g., FIG. 16G). Sometimes, thesearch keywords in the document display window are also highlighted.

Another application of the invention is to replace one text string withanother text string among a set of documents without having to open anyof them. For example, a user may like to change the name of a subjectfrom A to B within many documents of different types that cover thesubject. In some cases, the user may like to limit the change to certaintypes of documents or certain locations within the documents. Currently,the user has to open each document one by one and manually apply thechange. This is not only time-consuming but also error-prone.

FIG. 17A is a flowchart illustrative of a process of finding andreplacing text strings in connection with a set of search results basedon user instructions in accordance with some embodiments.

A computer receives a user request to replace a first text string with asecond text string in a first document and a second document (1702). Thefirst text string in the first document has a first content type and thefirst text string in the second document has a second content type,which is different from the first content type. The computer substitutesthe second text string for the first text string in the first documentand the second document (1704). The replacing second text string in thefirst document has the first content type and the replacing second textstring in the second document has the second content type.

FIG. 17B is a flowchart illustrative of a process of finding andreplacing text strings within a set of documents based on userinstructions in accordance with some embodiments.

After receiving a search request that includes one or moreuser-specified search keywords (1710), a computer identifies a firstdocument and a second document (1712), each document having at least onechunk that satisfies the search keywords. A first text string in thefirst document has a first content type and the first text string in thesecond document has a second content type, which is different from thefirst content type. After receiving a user request to replace the firsttext string with a second text string (1714), the computer substitutesthe second text string for the first text string in the first documentand the second document (1716). The replacing second text string in thefirst document has the first content type and the replacing second textstring in the second document has the second content type.

FIGS. 17C through 17E are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 17A and 17B in accordance with some embodiments.

FIG. 17C is a screenshot including a search assistant window 1722, whichoccupies the space in the application user interface previously occupiedby the document display window (see, e.g., FIG. 16J). In someembodiments, the search assistant window 1722 is activated by a userselection of the search assistant icon 1720. The search assistant window1722 includes three tabs, “Search Options,” “History,” and “Replace.”The “Replace” tab allows a user to replace one text string 1724 (“AlbertEinstein” in this example) with another text string 1726 (“A. Einstein”in this example) by clicking the “Update Content” button 1727.

In some embodiments, the “Replace” tab provides additional options 1728for the user to choose. For example, the user can limit the replacementto the selected search results in the search results window or relevantchunks in the identified documents, which documents result from a searchand display of chunks that satisfy user-specified search keywords. Notethat the text string 1724 to be replaced does not have to be related tothe user-specified search keywords. They can be the same or overlapping(as is the case in FIG. 17C) or completely different.

In some embodiments, the user can broaden the scope of the replacementto be the identified documents including, but not limited to, therelevant chunks. In some other embodiments, the user can further expandthe scope to cover all the documents whether or not they have a relevantchunk.

In some embodiments, the “Replace” tab also allows the user to specifythe locations within a document at which the replacement may happen. Forexample, FIG. 17C depicts target options 1729 that include multiplelocations, each having an associated checkbox. Thus, the user canstipulate that the first text string at one or more user-specifiedlocations in the first and second documents be replaced by the secondtext string by checking the respective checkboxes. As a result, thecomputer substitutes the second text string for the first text string atthe user-specified locations in the first document and the seconddocument, respectively. Possible locations within a document include oneor more selected from the group consisting of title, paragraph, table,header, footer, slide, spreadsheet, and all.

In some embodiments, after identifying the first document and the seconddocument, the computer displays a first chunk from the first documentand a second chunk from the second document, each chunk including atleast one instance of the first text string. The instances of the firsttext string within the first and second chunks are displayed in atext-only display format. As described above, a PowerPoint document anda Word document are identified as having chunks satisfying the searchphrase “Einstein general relativity.” The two relevant chunks aredisplayed in a text-only display format and different matching termstherein are highlighted in different colors.

In some embodiments, the first and second documents may have differentdocument type. Note that a document's document type is relevant to thedocument's distinct appearance when the document is rendered through itsnative application. For example, the first text string in the firstdocument may have a first appearance when the first document is renderedby its native application and the first text string in the seconddocument may have a second appearance that is different from the firstappearance when the second document is rendered by its nativeapplication.

In this example, the Word document and the PowerPoint document havedifferent document types because their contents have differentappearances when rendered by Microsoft Office. Sometimes, a document'ssuffix may uniquely identify its document type, e.g., a document withthe suffix “.docx” is a Microsoft Office 2007 Word document. Sometimes,a document's suffix cannot uniquely identify its document type, e.g.,documents like “hello.c” and “hello java” are probably both plain-textdocuments and therefore have the same document type.

FIG. 17D is a screenshot after the update is completed 1730. In someembodiments, replacing one text string with another text string does nottrigger an update of the chunks in the search results window. Thus, theinstances 1732, 1734 of the old text string “Albert Einstein” stillappear in the search results window. To view the replacing text string,the user has to perform a new search for the replacing text string.

As shown in FIG. 17E, in response to a new search request includingsearch keywords 1740 “Einstein general relativity,” the computer updatesthe chunks in the search results window, and as a result, “AlbertEinstein” is replaced with “A. Einstein.” Note that the instances 1742,1744 of the replacing second text string within the first and secondchunks are also displayed in the text-only display format.

In some embodiments, after substituting the second text string for thefirst text string, the computer also replaces the displayed instances ofthe first text string within the first and second chunks in the searchresults window with respective instances of the second text string.

In some embodiments, the first document includes an original second textstring that has a content type different from the replacing second textstring. For example, the Word document may include a PowerPoint slidethat has the phrase “A. Einstein,” but not the phrase “generalrelativity.” Assuming that the user limits the replacement to the chunksin the search results window, after the update, when the Word documentis rendered by Microsoft Office, the second text string has at least twodifferent appearances, one being a Word appearance and the other being aPowerPoint appearance.

Note that the methodology enabling the application of text stringfinding-and-replacement can be used for implementing otherdocument-editing features such as undoing or reversing last N editingoperations (including addition, deletion, and modification) applied to aset of documents and redoing or repeating N editing operations(including addition, deletion, and modification) applied to the set ofdocuments. The set of documents may be located at the same data sourceor distributed across multiple data sources.

Another application of the invention is to refine search results usingdifferent search keywords. For example, after conducting one searchusing a set of search keywords, a user may like to conduct anothersearch among the documents (or chunks) identified by the first searchusing another set of search keywords.

FIG. 18A is a flowchart illustrative of a first process of narrowingsearch results based on user instructions in accordance with someembodiments.

After receiving a first user request including a first set of searchkeywords (1801), a computer identifies a first set of chunks withinmultiple documents (1803). Each chunk includes terms matching the firstset of search keywords. The computer displays at least a portion of thefirst set of chunks (1805), including highlighting the terms matchingthe first set of search keywords in the displayed portion in a firstmanner. After receiving a second user request to search among thedocuments for documents that satisfy a second set of search keywords(1807), the computer identifies a second set of chunks within thedocuments (1809). Each chunk includes terms matching the second set ofsearch keywords. The computer displays at least a portion of the secondset of chunks (1811), including highlighting the terms matching thesecond set of search keywords in the displayed portion in a secondmanner that is different from the first manner.

FIG. 18B is a flowchart illustrative of a second process of narrowingsearch results based on user instructions in accordance with someembodiments.

After receiving a first user request including a first set of searchkeywords (1821), a computer identifies multiple documents (1823). Eachdocument includes at least one chunk that satisfies the first set ofsearch keywords. After receiving a second user request to search amongthe chunks in the identified documents for chunks that satisfy a secondset of search keywords (1825), the computer identifies a subset of thechunks (1827). Each chunk in the subset satisfies the second set ofsearch keywords.

Note that a user can repeat any of the two processes above for manytimes by providing different sets of search keywords for each searchstep until a predefined condition is met, e.g., the chunks of the user'sinterest have been found or no chunk is identified. At any time, theuser can roll back the search process to a previously-identified set ofchunks and try a different set of search keywords that has not been usedpreviously.

FIGS. 18C through 18D are screenshots of a graphical user interface on acomputer display illustrative of features associated with the processesas shown in FIGS. 18A and 18B in accordance with some embodiments.

The graphical user interface includes a first set of search resultsdisplayed in a text-only display format, each search result includingone or more chunks identified within a respective document as satisfyinga first set of search keywords. In response to a user request to searchamong the identified chunks for chunks that satisfy a second set ofsearch keywords, the first set of search results is replaced by a secondset of search results. Each search result in the second set includes oneor more chunks identified within a respective document as satisfyingboth the first set of search keywords and the second set of searchkeywords. In some embodiments, two chunks identified within twodifferent documents have different native display formats. In someembodiments, the second set of search keywords includes at least onesearch keyword that is not present in the first set of search keywords.

In some embodiments, terms matching the first set of search keywords andterms matching the second set of search keywords within a respectivechunk are highlighted in a visually distinguishable manner.

In some embodiments, the chunks identified within a respective documentas satisfying the first set of search keywords are displayed in an orderconsistent with their relative relevancy to the first set of searchkeywords, and the chunks identified within a respective document assatisfying both the first set of search keywords and the second set ofsearch keywords are displayed in an order consistent with their relativerelevancy to the second set of search keywords. In some otherembodiments, the chunks identified within a respective document assatisfying any of the first and second sets of search keywords aredisplayed in an order consistent with their relative locations withinthe corresponding document.

FIG. 18C is a screenshot including a first set of relevant chunks 1833identified within a PowerPoint document as satisfying the search keyword1831 “A. Einstein.” In some embodiments, the chunks 1833 are ordered bytheir respective relevancy to the search keywords 1831. In this example,the chunk 1835-B has a relative lower ranking metric when compared withthe other chunks above (e.g., 1835-A) and is therefore displayed at thebottom of the search results window. In some embodiments, if the subsetof chunks includes a first chunk and a second chunk, the computerdisplays the first chunk ahead of the second chunk in response to thefirst user request and displays the second chunk ahead of the firstchunk in response to the second user request.

FIG. 18D is a screenshot including a second set of relevant chunks 1843identified within the PowerPoint document as satisfying the searchkeyword 1841 “gravitation.” Note that the second set of search keywords1841 can be completely different from the first set of search keywords1831. In this example, the user has selected the checkbox next to the“Search Within Results” icon 1847. Accordingly, the search for thesecond set of chunks is limited to the documents identified as havingchunks that satisfy the search keywords 1831. In this case, it ispossible that the second set of chunks includes at least one chunk thatis not included in the first set of chunks. In some embodiments, thesearch for the second set of chunks is further limited to the chunks1833 that are identified by the first search.

In some embodiments, the second set of chunks includes at least onechunk that is included in the first set of chunks. For example, thechunks 1845-A, 1845-B in FIG. 18D are the same as the respective chunks1835-A, 1835-B in FIG. 18C. In some embodiments, the chunks 1835-A,1835-B are displayed in an order consistent with their relevancy to thefirst set of search keywords 1831 in the first set of chunks and thechunks 1845-A, 1845-B are displayed in an order consistent with theirrelevancy to the second set of search keywords 1841 in the second set ofchunks

In some embodiments, the terms in the chunks 1843 matching the first setof search keywords 1831 and the terms in the chunks 1843 matching thesecond set of search keywords are highlighted in different manner (e.g.,different colors, font type, etc.). In this example, the matching termsare displayed using larger, italic, and underlined font.

At any time, if the user is unsatisfied with the identified chunks 1843,the user can bring back the previously-identified chunks by clicking the“Previous” link 1849-A and restart the search process by entering adifferent set of search keywords. Similarly, the user can skip somesearch results by clicking the “Next” link 1849-B.

Another application of the invention is to minimize the response latencyby alternatively processing different node streams to identify therelevant chunk within a node stream as quickly as possible.

FIG. 19 is a flowchart illustrative of a process of alternativelyprocessing document node streams in accordance with some embodiments.

The computer identifies a first candidate document at a first datasource and a second candidate document at a second data source inresponse to a request from a user (1902). The request includes one ormore keywords. In some embodiments, the request is a search includingone or more search keywords. The computer generates a first node streamfor the first candidate document and a second node stream for the secondcandidate document using data packets received from the respective firstand second data sources (1904). The computer alternatively processes thefirst node stream and the second node stream until a candidate chunk isidentified therein (1906). In some embodiments, the candidate chunkincludes a set of nodes within a respective data source. Optionally, thecomputer returns the candidate chunk as a relevant chunk to the user ifthe candidate chunk satisfies the keywords (1908). Note that the firstdata source and the second data source may or may not be the same one.For example, they may be two different web servers. Thus, each candidatedocument can be an HTML web page.

In some embodiments, the computer submits an HTTP request to the firstdata source and receives an HTTP response from the first data source.The HTTP response may include multiple data packets corresponding to thefirst candidate document. After receiving one of the data packets fromthe first data source, the computer extracts one or more nodes from thedata packet and inserts the one or more nodes into the first nodestream. Sometimes, the computer may extract only a node fragment fromthe data packet if the node is too large to fit in a single data packet.In this case, the computer then forms a node by combining the nodefragment with another node fragment, which may be extracted from aprevious data packet, and insert the formed node (if the node is nowcomplete) into the first node stream.

In some embodiments, after processing nodes currently in the first nodestream, the computer waits for more nodes to appear in the first nodestream. If no new node appears in the first node stream for a firstamount of time, the computer may suspend processing the first nodestream and switch to process nodes currently in the second node streamand identify the candidate chunk in the second node stream, if there isany one.

In some embodiments, after processing the nodes currently in the secondnode stream, the computer may switch back to process nodes currently inthe first node stream if no new node appears in the second node streamfor the first amount of time and identify the candidate chunk in thefirst node stream, if there is any one.

In some embodiments, the computer may discard processing resultsassociated with one of the first node stream and the second node streamif no new node appears in the node stream for a second amount of time,which should be no less than and preferably longer than the first amountof time. For example, if there is a network traffic jam and the computerhas not received any data packet from a remote data source for arelatively long period of time, the computer can stop working on thecorresponding node stream and use the resources associated with the nodestream for other purposes, e.g., processing another node stream.

Note that the HTTP-related example above is for illustrative purposes.The process is equally applicable to any communication protocol in whichresponse latency is a concern, such as other TCP/IP based networkprotocols, file transfer protocol (FTP), or the like.

Another application of the invention is to provide a unified data modelfor documents having different structure types such as astrictly-structured XML document, a semi-structured HTML web page, andan unstructured plain-text document. This unified data model simplifiesthe process of identifying relevant chunks therein in response to a setof search keywords.

FIG. 20 is a flowchart illustrative of a process of semanticallyannotating documents of different structures in accordance with someembodiments.

After retrieving a document from a data source (2001), the computergenerates a customized data model (e.g., a hierarchical data mode) forthe document in accordance with its structure type (2003). In someembodiments, the structure type can be structured, semi-structured, andunstructured. The computer identifies one or more candidate chunkswithin the customized data model in accordance with a set of heuristicrules associated with the structure type (2005). Optionally, thecomputer selects one of the candidate chunks that satisfies one or moresearch keywords and returns it to an end user as a relevant chunk(2007).

In some embodiments, the data source is a web server and the document isan HTML web page that includes multiple pairs of HTML tags. In thiscase, the computer identifies a first subset of the HTML web pagebetween a first pair of HTML tags as a first candidate chunk if thefirst pair of HTML tags satisfies one of the set of heuristic rules. Ifnecessary, the computer recursively identifies a second subset of theHTML web page within the first subset of the HTML web page between asecond pair of HTML tags as a second candidate chunk if the second pairof HTML tags satisfies one of the set of heuristic rules.

In some embodiments, for a plain-text document, the computer generatesthe data model by heuristically inserting metadata such as XML tags intothe data model. The document contents following different XML tags areidentified to be different candidate chunks if they have predefinedtextual patterns. For example, a paragraph separated by blank lines is acandidate chunk and a sentence following a hyphen is also a candidatechunk if it is deemed to be part of a list of items.

Another application of the invention is to adaptively select matchingchunks from a plurality of candidate chunks identified within acandidate document in response to a search request so as to improve theusability of the chunks to the end user.

As noted above in connection with FIG. 12C, because the “‘Exact’ Match”and “Match All” options require all the search keywords find theirmatches in a chunk, they may ignore a chunk that, although highlyrelevant, fails to satisfy one of the search keywords. Alternatively,these two search options may return a chunk that, although satisfyingall the search keywords, is too long to retain the benefits an idealchunk should offer, e.g., being both precise and efficient in locatingthe information of the user's search interest. The latter case isespecially true if the candidate document has a hierarchical data modeland the search keywords spread over multiple layers of the data model.

On the other hand, the “Match Any” option accepts any chunk thatsatisfies at least one search keyword. This could end up with returningtoo many short chunks to a user, which is equally frustrating becausethe user has to review many remotely matching chunks before locating theinformation of the user's search interest or concluding that no suchinformation is in the document.

Fortunately, the “Best Match” option, as will be described below, cansuccessfully avoid the issues associated with these more polarizedsearch options by screening out chunks that are potentially moredistractive and presenting only chunks that satisfy a set ofcarefully-chosen criteria to the user.

FIG. 21A is a flowchart illustrative of a first process of screeningmatching chunks within a candidate document based on predefined criteriain accordance with some embodiments. In this application, a “matchingchunk” is defined as a candidate chunk that matches at least one searchkeyword. Certainly, a matching chunk could be an all-match if it matchesall the search keywords and even an exact-match if it matches the searchkeywords in exactly the same order.

Assume that a set of matching chunks within the candidate document havebeen identified and they are fed into a computer in an order consistentwith their respective locations in the document. The computer begins theadaptive process by checking if there is any more matching chunk to befurther processed (2102). If so (2102, yes), the computer receives thenext matching chunk (2104) and checks if the matching chunk meets thecurrent minimum matching level set for the document (2106).

In some embodiments, a matching chunk is characterized by one or moreattributes such as its matching level to the corresponding searchrequest and its length. For example, the matching level of a matchingchunk may be the total count of unique search keywords found within thechunk and the chunk's length may be the total count of words ornon-white-space characters in the chunk. Initially, the computer assignsa minimum matching level, e.g., one unique keyword per chunk, and arange of accepted chunk length, e.g., 50-70 words per chunk, to thecandidate document.

If the matching level of the next matching chunk is below the minimummatching level (2106, no), the computer invalidates the matching chunk(2110) and proceeds to the next one in the pipeline. If the matchinglevel of the next matching chunk is above the minimum matching level(2106, yes), the computer checks whether the chunk's length is withinthe range of accepted chunk length (2108). If the length of the chunk isoutside the scope of accepted chunk length (2108, no), either too longor too short, the computer repeats the same procedure of invalidatingthe matching chunk (2110) and proceeds to the next one in the pipeline.

Otherwise (2108, yes), the computer inserts the matching chunk into arespective queue in accordance with the chunk's match level (2112). Insome embodiments, matching chunks having different total counts ofunique search keywords are put into separate queues. In some otherembodiments, matching chunks having different sets of unique searchkeywords are grouped into separate queues. In either case, the computercalculates the current total count of matching chunks within thedifferent queues (2113).

If the total count of matching chunks is greater than a predefinedthreshold, e.g., 10 chunks per document, the computer updates thedocument's current minimum matching level (2114) by, e.g., increasingthe minimum matching level by one. As a result, at least one queue ofmatching chunks has a matching level less than the updated minimummatching level. In some embodiments, the computer invalidates the entirequeue of matching chunks, re-determines the current total count ofmatching chunks, and repeats this procedure until the total count ofmatching chunks is less than the threshold. Certainly, the computershould not invalidate any matching chunk if the total count of matchingchunks is less than the predefined threshold.

After updating the current minimum matching level, the computer checkswhether the current minimum matching level has reached the maximummatching level associated with the search request (2116). In someembodiments, the maximum matching level is defined by identifying abest-matching chunk such as an all-match chunk or an exact-match chunk.If true (2116, yes), the computer outputs all the best-matching chunksit has accumulated in one or more queues to the user (2118). By doingso, the computer effectively reduces the latency by serving thepresumably most relevant chunks to the user while continuouslyprocessing the other matching chunks. Otherwise (2116, no), the computerproceeds to the next one in the pipeline. In some embodiments, theoperations 2116, 2118 are optional and the computer postpones returningany chunk to the user until after processing all the matching chunks.

At the end of the aforementioned process, the computer should filter outmost, if not all, the distractive chunks that are presumably of littleinterest to the user and is now ready to serve the remaining matchingchunks in the queues to the user. Assuming that the computer has queuedmultiple groups of matching chunks (2120, yes), it begins with serving agroup of currently best-matching chunks to the user (2122). After that,the computer checks if the total count of matching chunks that have beenserved exceeds the predefined threshold or not (2124). If so (2124,yes), the computer stops the process of serving any more matching chunkseven if there are additional queues of un-served matching chunks. Bykeeping the total count of served matching chunks below the threshold,the computer can avoid overwhelming the user with too many chunks in thesearch results view. Otherwise (2124, no), the computer repeats theprocess of serving the group of second best-matching chunks until thepredefined threshold is met. In some embodiments, the computer stopsserving any matching chunk if no more matching chunks are left in anyqueue (2120, no). This may occur even if the total count of servedmatching chunks has not reached the predefined threshold.

In some embodiments, the matching chunks identified within a documenthaving a hierarchical data model are queued in an order such that adescendant matching chunk always precedes its ancestor matching chunksif they appear in the same queue. This ordering guarantees that thecomputer first serve the more refined descendant matching chunk beforeencountering any of the ancestor matching chunks because, as notedabove, the serving process proceeds from perfect-matching chunks to lessperfect ones. After serving the more refined descendant matching chunk,the computer also invalidates all the ancestor matching chunks in thesame queue since none of them are presumably more relevant than thedescendant chunk.

According to the aforementioned process, the matching chunks are servedin an order consistent with their relevancy to the search request, whichmay be different from the order of the chunks' locations in thedocument. For example, a best-matching chunk served before the othermatching chunks may be located at the end of the document and viceversa. In some embodiments, the computer may apply a two-phase processto ensure that the matching chunks be served in an order consistent withtheir locations in the candidate document:

-   -   Phase One—The computer screens the matching chunks as described        above, including assigning a monotonically increasing chunk        identifier to each matching chunk based on the matching chunk's        location in the document and invalidating any chunk and its        ancestors that fail to meet any of the predefined criteria,        without serving any chunk to an end user.    -   Phase Two—The computer sorts the surviving matching chunks        within different queues in accordance with their respective        chunk identifiers such that the first matching chunk to be        served is located above the other matching chunks in the same        document and outputs the matching chunks in this new sorted        order.

Note that there are many other approaches of outputting chunks in anorder consistent with their locations in the document. For example, thecomputer may generate a chunk linked-list during initial data modelgeneration or matching chunk screening process such that each chunkincludes a reference to the next chunk in the document. After thescreening process, the computer can output the result matching chunks inan order consistent with their locations in the document by navigatingthe chunk linked-list and skipping invalidated chunks.

FIG. 21B is an exemplary HTML document 2130 illustrative of the processas shown in FIG. 21A in accordance with some embodiments. Forillustration, the HTML document 2130 includes five matching chunks, eachchunk having a unique chunk ID “cid.”

Assume that there are seven user-specified search keywords,“Scintillating Examples of the Best Match Algorithm.” Further assumethat the predefined threshold of total chunk count is two (2), the rangeof accepted chunk length is 30-200 characters, and the initial minimummatching level is one keyword per chunk. The five matching chunks, eachsatisfying at least one of the seven search keywords, are fed into thecomputer in the order (as represented by their chunk IDs) of #2, #3, #1,#5, #4.

According to the flow chart shown in FIG. 21A, chunks #2 and #3 are bothplaced in Queue 4, which contains the chunks matching four searchkeywords, although the two chunks do not have the same four searchkeywords. Chunk #1 is placed in Queue 6, which contains the chunksmatching six search keywords. Since three chunks have been placed intodifferent queues, exceeding the threshold, the computer updates thecurrent minimum matching level from “one keyword per chunk” to “fourkeywords per chunk.”

Although containing four matching keywords, chunk #5 is nonethelessinvalidated because its length (26 characters) is outside the range ofaccepted chunk length. In contrast, chunk #4, which is a parent of chunk#5, is placed in Queue 4 for containing the same four matching keywordsand being longer than 30 characters.

After processing all the matching chunks, the computer begins outputtingthe matching chunks within different queues. In this example, thecomputer outputs the chunks in an order consistent with their respectiverelevancy to the search request. Thus, chunk #1 in Queue 6 is firstserved to the user. As noted above, the export of chunk #1 also causesthe invalidation of chunks #2 and #3 in Queue 4 because they aredescendants of chunk #1. Because Queue 5 is empty, the computer proceedsto Queue 4, which has only chunk #5 left for output. Finally, thecomputer stops the process after examining the queues of matching chunkswith a matching level no less than the current minimum matching level.

FIG. 21C is a flowchart illustrative of a second process of screeningmatching chunks within a document based on predefined criteria inaccordance with some embodiments.

A computer identifies within a document multiple matching chunks inresponse to a search request from a user (2142). In some embodiments,the search request includes one or more search keywords and each of themultiple matching chunks matches at least one of the search keywords.The computer partitions the matching chunks into multiple groups (2144).The matching chunks within a respective group have an associatedmatching level to the search request. In some embodiments, the partitionis a queuing process wherein chunks containing the same number ofmatching keywords are placed in the same queue. The computer returns oneor more groups of the matching chunks to the user in an order consistentwith their respective matching levels to the search request (2136). Insome embodiments, the computer displays a respective relevancy indicatoradjacent each of the returned matching chunks, indicating the relevancybetween the corresponding matching chunk and the search request. Therelevancy indicator can be formed using image, text, number or the liketo give the user an intuitive impression as to the matching chunk'sproximity to the search keywords.

In some embodiments, each of the search keywords has an associatedweight indicative of its relevance to the user's search interest.Different search keywords may have the same weight or different weights.Some of the search keywords may even have an associated weight of zero.For instance, in the example described above in connection with FIG.21B, the keyword “the” may be given a weight of zero and therefore haveno impact on the search results.

In some embodiments, the matching level of a respective group ofmatching chunks is, at least partially, determined by summing theweights of unique search keywords within one of the matching chunks. Forexample, the matching level of a respective group of matching chunks maybe, at least partially, determined by the number of unique searchkeywords within one of the matching chunks. If all the search keywords(including “the”) are given the same weight, chunks #2 and #3 would havethe same matching level and therefore be put in the same group.

In some embodiments, to partition the matching chunks into multiplegroups, the computer selects one of the matching chunks, determining thechunk's matching level and length, and invalidates the chunk if itsmatching level is less than a minimum matching level or if its length isoutside a predefined range of acceptable chunk length. If the selectedmatching chunk satisfies all the criteria including the minimum matchinglevel and the predefined range of acceptable chunk length, the computerinserts the chunk into one of the groups of matching chunks. As notedabove, the length of the matching chunk can be the total word count ofthe textual content of the matching chunk, or alternatively, the totalcharacter count of the textual content of the matching chunk afterwhite-space normalization.

In some embodiments, after selecting a matching chunk that satisfies allthe criteria, the computer compares the chunk's matching level to thematching level of a respective group of matching chunks untilidentifying a group of matching chunks whose matching levels are thesame or similar to the selected chunk's matching level and then adds thechunk to the group of matching chunks.

In some embodiments, after placing a matching chunk within a group orexporting a matching chunk to the end user, the computer checks whetherthere are any chunks within the same group that are descendants of thenewly-placed or newly-exported matching chunk in a hierarchical datamodel of the document. If so, the computer then invalidates thedescendant matching chunks from the group of matching chunks becausethey are redundant chunks from the user's perspective.

In some embodiments, after inserting one matching chunk into a group ofmatching chunks, the computer determines a total count of matchingchunks whose matching levels are no less than the minimum matching leveland updates the current minimum matching level if the total count ofmatching chunks is greater than a predefined count threshold.Additionally, the computer may invalidate at least a subset of one ofthe groups of matching chunks whose matching levels are less than theupdated minimum matching level.

In some embodiments, if there are multiple groups of matching chunks(e.g., Queue 6 and Queue 4 in the example shown in FIG. 21B), thecomputer selects among the groups of matching chunks a group of matchingchunks that has a highest matching level (e.g., Queue 6) and returns theselected group of matching chunks to the user. If there are still groupsof matching chunks left, the computer then returns to select a group ofmatching chunks having a next highest matching level (e.g., Queue 4)until the total count of the returned matching chunks is not less than apredefined count threshold.

FIG. 21D is a screenshot of a graphical user interface on a computerdisplay illustrative of features associated with the processes as shownin FIGS. 21A and 21B in accordance with some embodiments. In thisexample, the search keywords box includes five search keywords 2150,“distance between earth and moon,” and the “Best Match” search option ischosen for selecting matching chunks.

Based on these search keywords, it is not difficult to appreciate thatthe user is probably interested in knowing the spatial distance betweenthe earth and the moon. But as shown in FIG. 21D, the search result 2154provided by a generic search tool is not satisfactory because it hasnothing to do with the answer expected by the user although all the foursearch keywords are present in the search result (note that the term“and” is treated as a stop-word with no weight).

In contrast, a process according to some embodiments of the inventionidentifies multiple matching chunks within the same document, 2152-Athrough 2152-C, different chunks having different numbers of searchkeywords. In this example, the matching chunks are ordered by theirmatching levels to the search keywords. Therefore, the matching chunk2152-A appears before the other two chunks because it includes at leastone instance of each of the four search keywords, which is essentiallyan all-match chunk. But this chunk does not have the answer to theuser's question either. Actually, it is the second matching chunk 2152-Bthat, although having no match for the search keyword “between,” has theanswer to the user's question, that is, the phrase 2156 “distance fromthe Earth to the Moon is 384,403 km.” Thus, the user receives asatisfactory answer to his or her question from the matching chunkswithout visiting any of the candidate documents. Note that the samematching chunk 2152-B would have been ignored by the “Match All” and“‘Exact’ Match” options because it does not have the keyword “between.”

Another application of the invention is to search a set of inter-relateddocuments for contents matching a search request. This application isdifferent from the conventional search tools, which always treat theInternet as the search space and perform all the searches in the entiresearch space no matter how irrelevant most of the documents in the spaceare to the user-specified search keywords. Consequently, many documentsidentified by the conventional search tool, although have nothing to dowith the user's search interest, end up occupying prominent spots in thesearch results window. If a user is allowed to narrow the search spaceto a small set of user-specified documents, it is possible for acomputer to produce more relevant search results at a fraction of thecost wasted by the conventional search tools.

FIG. 22A is a flowchart illustrative of a process of identifyingcontents matching a search request within a plurality of inter-relateddocuments in accordance with some embodiments. In this application, afirst document is inter-related to a second document if the firstdocument includes a document link that either directly references thesecond document or indirectly references the second document byreferencing a third document that directly or indirectly references thesecond document. The first document is also inter-related to the seconddocument if they are both directly or indirectly referenced by a thirddocument. As such, different documents referenced by respective documentlinks within an HTML web page are referred to as “inter-relateddocuments.” In this case, the HTML web page is called “primary document”and the documents referenced by the web page are called “secondarydocuments.”

A computer receives a request to search one or more secondary documents(2201). At least one of the secondary documents is associated with aprimary document. The computer searches at least a subset of thesecondary documents for documents that satisfy the search request (2203)and identifies at least one secondary document that satisfies the searchrequest (2205).

In some embodiments, the computer first displays the primary document(e.g., a web page) on a display device (e.g., a computer monitor) beforereceiving the search request from a user. The primary document includesone or more document links, each document link referencing one of thesecondary documents. After identifying the secondary document, which maybe another web page or the like, the computer displays at least aportion of the identified secondary document to the user. The displayedportion of the secondary document preferably includes one or more searchkeywords in the search request.

In some embodiments, the computer locates within the identifiedsecondary document one or more chunks that satisfy the search requestusing the approaches as described above and displays one or more of theidentified chunks to the user.

In some embodiments, the primary document includes many document linkspointing to a large number of secondary documents, many of which mayhave nothing to do with the user's search interest. For example, manyweb pages include links to boilerplate-type secondary documents such as“About Us,” “Contact Us,” “Sitemap,” “Disclaimer,” etc. Searching outthese secondary documents rarely returns any useful search results.Thus, in some embodiments, rather than searching all the secondarydocuments referenced by the primary document, the user is allowed toselect a subset of secondary documents to be searched by identifyingdocument links associated with the user-selected secondary document.

For example, each of the subset of secondary documents can be selectedby a respective mouse click of the corresponding document link in theprimary document. Alternatively, the computer defines a region in theprimary document using an input device and then identifies documentlinks within the defined region as the user-selected document links. Forexample, the computer presses down a mouse's button at a first locationand drags the mouse from one location to another location untilreleasing the mouse's button at a second location. By doing so, theuser-selected region is a rectangle area defined by the first locationand the second location and all the document links falling into thisrectangle area are document links to secondary documents to be furthersearched in response to a search request.

In some embodiments, the computer searches both the primary andsecondary documents for chunks that satisfy the search request, and as aresult, identifies at least one chunk in the primary document and atleast one chunk in one of the secondary documents, both chunkssatisfying the search request. The chunks associated with the primaryand secondary documents are visually separated by a bar such that it isintuitive for a user to distinguish chunks identified within the primarydocument and chunks identified within the secondary documents.

In some embodiments, the search of secondary documents is a recursiveprocess. In response to a user request to search a secondary document,the computer recursively retrieves the secondary document and documentsreferenced by this secondary document. Thus, the search results may notonly include chunks identified within the primary document but alsochunks within a secondary document that is indirectly referenced by theprimary document.

FIGS. 22B through 22D are screenshots of a graphical user interface on acomputer display illustrative of features associated with the process asshown in FIG. 22A in accordance with some embodiments.

FIG. 22B is a screenshot of a web browser window rendering a web pageidentified by the URL 2211http://www.rainingdata.com/products/index.html. There are twouser-specified search keywords 2213 “tigerlogic xdms” in the search box.The screenshot depicts at least chunks 2217-A through 2217-D that matchthe two search keywords. The web page includes many document links. Someof the document links (e.g., links 2219) are likely to be related to thesearch keywords 2213 and others (e.g., links 2220) probably have nothingto do with the search keywords 2213. In this example, the user avoidssearching secondary documents associated with the links 2220 by eithermouse-clicking the links or defining a rectangle region covering thelinks.

After a user mouse-click of the “Chunk Page Links” icon 2215, thecomputer generates a plurality of chunks identified within the primarydocument and the secondary documents identified by the links 2219 asshown in the screenshot of FIG. 22C. Note that the search results 2221associated with the primary document (including the chunks 2217-Athrough 2217-C) are separated from the search results 2225 and 2229,which are associated with the two secondary documents identified by thetwo links 2219, each including a respective set of matching chunks2227's and 2231's. FIG. 22D is another screenshot that only depicts thesearch results from the secondary documents, nothing from the primarydocument.

FIG. 23 is a block diagram of an exemplary document search server 2300computer in accordance with some embodiments.

The exemplary document search server 2300 typically includes one or moreprocessing units (CPU's) 2302, one or more network or othercommunications interfaces 2310, memory 2312, and one or morecommunication buses 2314 for interconnecting these components. Thecommunication buses 2314 may include circuitry (sometimes called achipset) that interconnects and controls communications between systemcomponents. The document search server 2300 may optionally include auser interface, for instance a display and a keyboard. Memory 2312 mayinclude high speed random access memory and may also includenon-volatile memory, such as one or more magnetic disk storage devices.Memory 2312 may include mass storage that is remotely located from theCPU's 2302. In some embodiments, memory 2312 stores the followingprograms, modules and data structures, or a subset or superset thereof:

-   -   an operating system 2316 that includes procedures for handling        various basic system services and for performing hardware        dependent tasks;    -   a network communication module 2318 that is used for connecting        the document search server 2300 to other servers or computers        via one or more communication networks (wired or wireless), such        as the Internet, other wide area networks, local area networks,        metropolitan area networks, and so on;    -   a system initialization module 2320 that initializes other        modules and data structures stored in memory 2312 required for        the appropriate operation of the document search server 2300;    -   a query engine 2322 for processing a user-driven search query        and preparing relevant chunks in response to the search query;    -   a cache engine 2324 for identifying candidate documents in        response to the search query;    -   a stream engine 2326 for retrieving candidate documents and        identifying candidate chunks therein; and    -   an index database 2328 for storing index information of a number        of candidate documents 2330 accessible to the document search        server 2300.

FIG. 24 is a block diagram of an exemplary client computer 2400 inaccordance with some embodiments.

The exemplary client computer 2400 typically includes one or moreprocessing units (CPU's) 2402, one or more network or othercommunications interfaces 2410, memory 2412, and one or morecommunication buses 2414 for interconnecting these components. Thecommunication buses 2414 may include circuitry (sometimes called achipset) that interconnects and controls communications between systemcomponents. The client computer 2400 may include a user input device2410, for instance a display and a keyboard. Memory 2412 may includehigh speed random access memory and may also include non-volatilememory, such as one or more magnetic disk storage devices. Memory 2412may include mass storage that is remotely located from the CPU's 2402.In some embodiments, memory 2412 stores the following programs, modulesand data structures, or a subset or superset thereof:

-   -   an operating system 2416 that includes procedures for handling        various basic system services and for performing hardware        dependent tasks;    -   a network communication module 2418 that is used for connecting        the client computer 2400 to the document search server 2300 or        other computers via one or more communication networks (wired or        wireless), such as the Internet, other wide area networks, local        area networks, metropolitan area networks, and so on;    -   a system initialization module 2419 that initializes other        modules and data structures stored in memory 2412 required for        the appropriate operation of the client computer 2400;    -   a web browser 2420 for retrieving and displaying candidate        documents including web pages from remote web servers;    -   a search toolbar 2425 attached to the web browser 2420 for        identifying relevant chunks within the retrieved candidate        document and displaying the relevant chunks;    -   one or more applications 2430 such as Microsoft Office Word        application 2431, Microsoft Office PowerPoint application 2433,        Microsoft Office Excel application 2435, etc.; and    -   an add-in application 2437 attached to the Microsoft Office        applications for displaying relevant chunks associated with        user-specified search keywords and re-using the relevant chunks        based on user instructions.

The foregoing description, for purpose of explanation, has beendescribed with reference to specific embodiments. However, theillustrative discussions above are not intended to be exhaustive or tolimit the invention to the precise forms disclosed. Many modificationsand variations are possible in view of the above teachings. For example,the aforementioned processes of identifying a relevant chunk within adocument are by no means limited to a particular language such asEnglish. Actually, the same processes are equally applicable todocuments written in other languages and/or multi-lingual documents. Theembodiments were chosen and described in order to best explain theprinciples of the invention and its practical applications, to therebyenable others skilled in the art to best utilize the invention andvarious embodiments with various modifications as are suited to theparticular use contemplated.

1. A computer-implemented method, comprising: at a computer havingmemory, a display, and one or more processors, receiving a searchkeyword provided by a user, wherein the search keyword satisfies apredefined expression pattern; determining an archetype for the searchkeyword; identifying a query operator for the archetype, wherein thequery operator includes a generalized expression of the search keyword;applying the identified query operator to a document; identifying achunk within the document that satisfies the identified query operator,wherein the chunk does not include an instance of the search keyword;and returning the chunk for display to the user.
 2. The method of claim1, wherein the archetype has an enumerable set of instances and thesearch keyword is associated with one of the instances.
 3. The method ofclaim 1, wherein the identified query operator has a parameter defininga numeric scope.
 4. The method of claim 3, wherein the scope is from 0%to 100%.
 5. The method of claim 1, wherein the identified query operatorhas a parameter defining an expression pattern.
 6. The method of claim5, wherein the pattern is a date pattern.
 7. The method of claim 1,further comprising: before applying the identified query operator,receiving one or more user instructions in connection with thearchetype; and updating the identified query operator in accordance withthe user instructions.
 8. The method of claim 7, further comprising:before applying the identified query operator, providing one or moresuggestions in response to the user instructions; receiving new userinstructions in connection with the archetype and the suggestions;updating the identified query operator in accordance with the new userinstructions; and repeating said providing, receiving, and updatingsteps until after receiving a search query execution request from theuser.
 9. A computer system, comprising: memory; a display; one or moreprocessors; one or more programs stored in the memory and configured forexecution by the one or more processors, the one or more programsincluding: instructions for receiving a search keyword provided by auser, wherein the search keyword satisfies a predefined expressionpattern; instructions for determining an archetype for the searchkeyword; instructions for identifying a query operator for thearchetype, wherein the query operator includes a generalized expressionof the search keyword; instructions for applying the identified queryoperator to a document; instructions for identifying a chunk within thedocument that satisfies the identified query operator, wherein the chunkdoes not include an instance of the search keyword; and instructions forreturning the chunk for display to the user.
 10. The computer system ofclaim 9, wherein the archetype has an enumerable set of instances andthe search keyword is associated with one of the instances.
 11. Thecomputer system of claim 9, wherein the identified query operator has aparameter defining a numeric scope.
 12. The computer system of claim 11,wherein the scope is from 0% to 100%.
 13. The computer system of claim9, wherein the identified query operator has a parameter defining anexpression pattern.
 14. The computer system of claim 13, wherein thepattern is a date pattern.
 15. The computer system of claim 9, furthercomprising: before applying the identified query operator, instructionsfor receiving one or more user instructions in connection with theselected archetype; and instructions for updating the identified queryoperator in accordance with the user instructions.
 16. The computersystem of claim 15, further comprising: before applying the identifiedquery operator, instructions for providing one or more suggestions inresponse to the user instructions; instructions for receiving new userinstructions in connection with the archetype and the suggestions;instructions for updating the identified query operator in accordancewith the new user instructions; and instructions for repeating saidproviding, receiving, and updating steps until after receiving a searchquery execution request from the user.
 17. A computer readable storagemedium having stored therein instructions, which when executed by acomputer system cause the computer system to: receive a search keywordprovided by a user, wherein the search keyword satisfies a predefinedexpression pattern; determine an archetype for the search keyword;identify a query operator for the archetype, wherein the query operatorincludes a generalized expression of the search keyword; apply theidentified query operator to a document; identify a chunk within thedocument that satisfies the identified query operator, wherein the chunkdoes not include an instance of the search keyword; and return the chunkfor display to the user.
 18. The computer readable storage medium ofclaim 17, wherein the archetype has an enumerable set of instances andthe search keyword is associated with one of the instances.
 19. Thecomputer readable storage medium of claim 17, wherein the identifiedquery operator has a parameter defining a numeric scope.
 20. Thecomputer readable storage medium of claim 19, wherein the scope is from0% to 100%.
 21. The computer readable storage medium of claim 17,wherein the identified query operator has a parameter defining anexpression pattern.
 22. The computer readable storage medium of claim21, wherein the pattern is a date pattern.
 23. The computer readablestorage medium of claim 17, further comprising: before applying theidentified query operator, instructions for receiving one or more userinstructions in connection with the selected archetype; and instructionsfor updating the identified query operator in accordance with the userinstructions.
 24. The computer readable storage medium of claim 23,further comprising: before applying the identified query operator,instructions for providing one or more suggestions in response to theuser instructions; instructions for receiving new user instructions inconnection with the archetype and the suggestions; instructions forupdating the identified query operator in accordance with the new userinstructions; and instructions for repeating said providing, receiving,and updating steps until after receiving a search query executionrequest from the user.